Fibonnacci y la Recursividad

Les comparto paso a paso como entenderle al algoritmo de Fibonacci-recursividad, ya que a mi me costo bastante, espero que les sirva de referencia.

🔴No esperen a la siguiente clase. 🔴
.
Resuelvan sus dudas aquí: Recursion, the Fibonacci Sequence and Memoization || Python Tutorial || Learn Python Programming
.
Aquí la Playlist mas hardcore del mundo: Python
.
🥗 ¡Éxito!

Creo que estaría bien explciar mes por mes como va evolucionando el ejercicio. En el mes 1 solo hay una hembra, esa hembra da a luz a otra hembra, por ello en el mes 2 hay 2 hembras, pero solo una de ellas fertil, por lo que la unica hembra fertil tiene 1 hembra, para el mes 3 hay 3 hembras, en este mes, la hembra del mes 1 ya vuelve a ser fertil y la que era fertil en el mes 2 ya no lo es, en el mes 3 hay 2 hembras fertiles, estas hembras dan a luz 1 hembra cada una. Por ello en el mes 4 hay 5 hembras, de las cuales 2 no son fertiles, las 3 restantes dan a luz hembra cada una y para el mes 5 hay (5+3) 8 hembras, pero solo 5 fertiles, ya que 3 de estas 8 acaban de dar a luz. Y asi sucesivamente. Espero que se entienda y que este en lo correcto. Cualquier aclaración y/o corrección es bienvenida.

Creo que la manera más fácil de entender esto es tal y como lo dice la Wikipedia: el número siguiente es la suma de los dos números anteriores:

n: El número buscado
n-1: El número anterior
n-2: El número anterior al anterior

Aunque se puede resolver con recursividad, creo que sería más fácil y tal vez más eficiente con un ciclo 🤔

La sucesión de Fibonacci en la naturaleza

Mirar este articulo esta muy interesante la sucesión de Fibonacci en la naturaleza.

Otros ejemplos de funciones recursivas son:

1. Triángulo de Pascal (la dsposición de números tales que cada fila corresponde a los coeficientes del binomio (a+b)^n donde n representa el numero de filas. La fila n se obtiene de la fila n-1, Rn(i)=Rn-1(i-1)+Rn-1(i) ).
2. Polinomios de Hermite (los polinomios de Hermite de orden n>2 se pueden expresar en términos de los dos primeros polinomios H0(x) y H1(x), Hn(x) = 2x*Hn-1(x) - 2(n-1)Hn-2(x) )

Este tema de recursividad me parece que la practica solamente hará que uno lo domine, pero aquí durante estas clases se nos muestra cuando una función se llama a uno mismo, pero el principio de recursividad al menos a nivel matemático es poder descomponer una operación en operaciones mas simples o también viceversa, por ejemplo si alguien te pide realizar la suma que del 21 + 22 + 23 + … +100, para solucionarlo lo que haríamos es un for que inicie de 21 y al final que llegue al 100 para sumarlo de manera de que sume que da como resultado 4840, dependiendo del numero de inicio y numero final serian muchas iteraciones, pero hay una manera muy fácil de hacerlo, ya que se puedes simplificarlo de la siguiente manera:

Sabemos que 100 + 21 es igual a 121, también sabemos que 99 + 22 es igual a 121, y que 98 +23 es igual a 121

Este resultado se repite y dará el mismo resultado, entonces podemos predecir que los números centrales de la suposición anterior darán 121, por lo que podemos decir que esta operación se repetirá 40 veces que es la mitad de los ciclos que haría el for por lo tanto podemos ahorrarnos el for y hacer la siguiente simple operación
(21 + 100) * 40 = 21 + 22 + 23 …+ 100.

total = 0
    limite_inf = int(input("Escribe el valor en donde comenzara la sumatoria: "))
    limite_sup = int(input("Escribe el valor final que sumara la suma"))

    for numero in range(limite_inf, limite_sup):
        total += numero
        print(numero)

    print(total)
    repeticiones = (limite_sup - limite_inf)/2
    print(repeticiones)
    resultado_simplificado = (limite_sup + limite_inf - 1)*repeticiones
    print(resultado_simplificado)

Esto siempre y cuando las repeticiones sean pares aunque para las impares solo se necesita eliminar el ultimo numero para tener una repetición par poder hacer la operación simple, y el resultado sumarle el excedente para tener el resultado correcto.

Para poder entenderlo un poco mejor, use ambas maneras, en iteración y en recursividad:

Con este video terminé de entender la Secuencia Fibonacci:
https://www.youtube.com/watch?v=DKGsBUxRcV0

explicacion mas bonita haciendo clic aqui
Imagina que agregamos el numero 1
Entraría en el if por lo tanto hasta ahí llegaría nuestro programa

Si elegimos el numero 2
Se brinca el if porque pues no cuenta, y se va directo al return que llama directo a la función, por lo que obtenemos el primer atributo del return fibonacci(2 - 1), y como es igual a 1, retornamos el 1. el segundo punto es fibonacci(n - 2) por lo que su respuesta es 0 al volver a la función, pero en la condición vemos que si es 0 retorna un 1. es decir que al momento de retornar tenemos 1 + 1.

Si elegimos el numero 3

Entramos a la función con n=3, por lo que nos brincamos el if, el primer resultado del retorno es fibonacci(3 - 1), es decir que volvemos a entrar la función con fibonacci(2), por lo que nos brincamos el if y nos vamos al return. Espero te hayas dado cuenta, obtenemos el resultado de si hubiéramos elegido el numero dos, si no te queda claro sigue los pasos de arriba donde dice ‘si elegimos el numero 2’.

El chiste que de la línea return ya tenemos el primer termino que es 1+1 que es igual a fibonacci(2). Ahora calculamos el otro numero fibonacci(3-2) que seria igual a fibonacci(1) por lo tanto seria igual a 1.

Por si acaso te dire qué está pasando aqui, el return principal se encarga de hacer una lista de sumas de puros digitos 1.

Es decir que tu al buscar el fibonacci de algún numero, el resultado es la suma de 0+1 n veces.

Un ejemplo mas: tu al buscar el fibonacci de 6 su resultado será el return que llamo a la misma función 13 veces sumando 1+1+1+1+1+… hasta obtener 13. Cada iteración sumó un 1 al resultado

Si elegimos el numero 4
Este ejemplo será mas gráfico

fibo(4)
= fibo(4-1) + fibo(4-2)
= fibo(3) + fibo(2)
= (fibo(3-1) + fibo(3-2))  + (fibo(2-1) + fibo(2-2))
= (fibo(2) + fibo(1))  + (fibo(1) + fibo(0))
= ((fibo(2-1) + fibo(2-2)) + fibo(1))  + (fibo(1) + fibo(0))
= ((fibo(1) + fibo(0)) + fibo(1))  + (fibo(1) + fibo(0))
= ((1 + 1) + 1) + (1 + 1))
= 1 + 1 + 1 + 1 + 1
= 5

def fibonacci(n):
  print(n)
  if n == 0 or n == 1:
    return 1
  
	return fibonacci(n - 1) + fibonacci(n - 2)

n = int(input('Ingresa un numero: '))

print(f'El numero final fibonacci es {fibonacci(n)}')

Cómo opera la serie de Fibonacci:

Genera el número siguiente agregando dos números anteriores. Es decir, comienza con dos números: F0 y F1. Los valores iniciales de F0 y F1 se pueden tomar 0, 1 o 1, 1 respectivamente.

Se tienen que cubrir las siguientes condiciones:

Fn = Fn-1 + Fn-2

Hola a todos, es importante tener en cuenta que la sucesión de fibonacci siempre inicia en F0 = 0, matemáticamente la definición de recurrencia esta dada por:

Se puede leer un poco más en la Wiki. Con la anterior definición de recurrencia se implementa el algoritmo recursivo en Python o en cualquier otro lenguaje que les guste. Este fue el que implementé en código Python:

def fibonacci(n):
    """Calcula el n-esimo elemento sucesión fibonacci.
    params:
        n: int -- n-esimo elemento
    return:
        fibonacci(n): int
    """
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

Aclarar que para el ejemplo que da el profesor David, referente a los conejos, se puede crear confusión ya que para este problema al mes 0, se tiene 1 pareja de conejos. Luego en el mes 1 esta pareja de conejos se cruza, pero aún sigue existiendo la misma pareja (1 pareja de conejos).

Finalmente para el mes 2 la pareja da a luz otra pareja de conejos, entonces ya se tienen 2 parejas y nuevamente la pareja que ya existía vuelve a cruzarse y así continúa el ciclo.

• Inicio Mes 0: Tengo 1 pareja conejos (Pareja A).
• Mes 1: Pareja de conejos A se cruzan. Aún tengo 1 pareja de conejos.
• Mes 2: Pareja de conejos A da a luz otra pareja B, y vuelven a cruzarse pareja conejos A. Ahora tengo 2 parejas A y B.
  .
  .
  .
  y así continúa el ciclo. Así que para una implementación correcta de Fibonacci, debe utilizarse la definición matemática de recurrencia que mostré al inicio, ya que lo referente a los conejos es una forma de explicar la sucesión.

Espero sea útil el aporte. Un saludo a todos.

En este video se da una excelente explicación de esta clase y la pasada. Espero les sirva.

Mi código:

def main():

    def fibonacci(n):
        # print(n)
        if n==0 or n==1:
            return 1
        return fibonacci(n-1)+fibonacci(n-2)

    print('Sucesion de fibonacci')
    numero = int(input('Introduce cuantos numeros de fibonacci quieres generar: '))

    for i in range(numero):
        print(i,fibonacci(i))

if __name__ == "__main__":
    main()

y lo que regresa:

Sucesion de fibonacci
Introduce cuantos numeros de fibonacci quieres generar: 20
0 1
1 1
2 2
3 3
4 5
5 8
6 13
7 21
8 34
9 55
10 89
11 144
12 233
13 377
14 610
15 987
16 1597
17 2584
18 4181
19 6765

Así para imprimir una determinada cantidad de números de la serie

def fibonacci(n, i=0, j=1):
    print(i+j)
    return fibonacci(n-1, i+j, i) if n > 1 else 0


if __name__ == '__main__':
    fibonacci(int(input('Cuantós número de la serie desea imprimir?: ')))

Si no entendieron muy bien de qué va pueden echarle un vistazo a este video:

https://www.youtube.com/watch?v=k6I_TOW6O2o&ab_channel=KhanAcademyEspañol

La sucesión de Fibonacci es la sucesión de números que, empezando por la unidad, cada uno de sus términos es la suma de los dos anteriores (1,1,2,3,5,8,13,…).

Les comparto mi código que imprime la secuencia fibonacci hasta el número que elijan

<numero = int(input ('escoge un número para la secuencia fibonacci: \n'))

i = 0
    
def fibonacci (num):
    """
    Devuelve el valor del numero para la serie fibonacci
    numero int > 0
    returns secuencia fibonacci
    """
    if num == 0 or num ==1:
        return 1
    return fibonacci(num-1) + fibonacci (num-2) 

print ('Puesto', 'Valor')
while (i < numero):
    print (i,'    ', fibonacci (i))
    i = i + 1>

E imprime como resultado lo siguiente:

<escoge un número para la secuencia fibonacci: 
10
Puesto Valor
0      1
1      1
2      2
3      3
4      5
5      8
6      13
7      21
8      34
9      55>

Sucesión de Fibonacci
Es una serie matemática infinita, donde:
0 1 1 2 3 5 8 13 21 …
Donde la suma de los dos números anteriores da el resultado del
Numero actual
A=5
B=8
A + B = 13
C=13
B + C = 21
D=21

Gracias!

def fibonnacci(n):
    if (n == 1 or n == 0):
        return 1

    return fibonnacci(n-1) + fibonnacci(n-2)


numero = int(input('Ingrese la cantidad de numeros a generar : '))

for i in range(numero+1):
    print(f'Num {i} ==> {fibonnacci(i)}')

Conozco otra definición de recursividad llamada Recursión de Cola o Tail Recursion que es un mecanismo que permite tener funciones recursivas sin temer por posibles desbordamientos de pila. A diferencia de la recursividad clásica, donde cada llamada recursiva implica la creación de un nuevo frame en la pila de llamadas (con el riesgo de desbordamiento), con el tail recursion es posible realizar dichas llamadas recursivas reaprovechando el frame de pila anterior y evitando así el desbordamiento.

Ejemplo Tail Fibonacci

def tail_fibonacci(n, a = 0, b = 1): 
    if n == 0:
        return a
    if n == 1: 
        return b
    return tail_fibonacci(n - 1, b, a + b)

def fibonacci(n):
    return tail_fibonacci(n)

n = int(input("Digite un número: "))
print(f'Por recusión de cola fibonacci {n} es {fibonacci(n)}')

La recursividad tambien sirve para probar cosas.
Existe algo llamado inducción matematica, sirve para probar si una formúla, teorema o afirmación es verdadera.
La inducción matematica usa recursividad, ejemplo:
Dada la siguiente sumatoria, prueba que la formúla es verdad para n >= 1

def sumatoria(n):
	if n == 1:
		return 1
	return n + sumatoria(n - 1)

Acá dejó la solución con recursividad y con un bucle for ya que la recursividad no es la solución óptima para resolver este problema por la complejidad algorítmica que representa.

def fibonacci(n):
    """Calcula el fibonacci por recursion 
    
    Params:
        n: int

    Return:
        fibonacci(n) : int
    """
    if n == 0 or n == 1:
        return 1

    return fibonacci(n-1) + fibonacci(n-2)

def fibonaccifor(n):
    """Calcula el fibonacci por bucle for 
    
    Params:
        n: int

    Return:
        b: int
    """
    a = 0
    b = 1
    
    for i in range(n):
        c = a + b
        a = b
        b = c

    return b

def run():
    n = int(input('Ingresa un numero: '))
    print(fibonaccifor(n))


if __name__ == '__main__':
    run()

Algo que debería ser mencionado es que hay maneras de optimizar la recursividad. Ya que el problema de la recursividad es que al realizar cálculos con un n lo suficientemente grande, la función recursiva se llama así misma hasta llegar a la última llamada y luego se devuelve.

Dejo a continuación un programa de recursividad de Fibonacci.Sugiero utilizar para este programa n = 412, ya que pasaran minutos y aún su equipo no habrá realizado el cálculo.

# Autor:
#   Sergio Carrillo
#   @SergioAmaro_

# Última fecha de modificación:
#   29/01/2021

def fibonacci(n):
  """Calcula Fibonacci(n) mediante recursión por cola

  Args:
      n ([int]): [n>=0]

  Returns:
      [int]: []
  """
  a, b = 0, 1
  
  if n == 0: 
    return a
  elif n == 1: 
    return b
  elif n > 1: 
    return fibonacci(n-1) + (fibonacci(n-2))


def main():
  n = int(input('Ingresa un número entero: '))
  print(fibonacci(n))

if __name__ == '__main__':
  main()

Por otra parte existe la recursividad por cola, y esta nos permite ir acumulando el cálculo sin necesidad de esperar llegar a la última llamada de la función para devolverse. Sugiero investigar:

Dejo a continuación un programa que plantea el mismo ejercicio solucionando con recursividad por cola. Pueden calcular Fibonacci(412) y el cálculo será en cuestión de segundos. En comparación al programa anterior, plantear soluciones con este método es mucho más eficiente en términos de recursos.

# Autor:
#   Sergio Carrillo
#   @SergioAmaro_

# Última fecha de modificación:
#   29/01/2021

def tailFibo(n):
  """Calcula Fibonacci(n) mediante recursión por cola

  Args:
      n ([int]): [n>=0]

  Returns:
      [int]: []
  """
  a, b = 0, 1
  def go(n, a, b):
      if n == 0: return a
      elif n == 1: return b
      elif n > 1: return go(n-1, b, a+b)

  return go(n, a, b)


def main():
  n = int(input('Ingresa un número entero: '))
  print(tailFibo(n))

if __name__ == '__main__':
  main()

#Hola Chic@s pueden practicar con el projecto Euler he aqui un ejemplo

#Problem 2
"""Each new term in the Fibonacci sequence is generated by adding the previous two terms.
By starting with 1 and 2, the first 10 terms will be:

1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...

By considering the terms in the Fibonacci sequence whose values do not exceed four million,
find the sum of the even-valued terms."""

x = [1, 2]
Number_final = int(input('How many numbers do you want ?'))
#Which_number = int(input('Which number of the list do you want? '))

for i in range(Number_final):
	x.append(x[-1]+x[-2])
	i += 1
#print(x[Which_number])
total = 0
#Now we will get the even summ 
for i in x:
	if i % 2 ==0:
		total = total + i
print(total)

Una explicación gráfica respecto al tema:

💻Por si alguien lo necesita para futuras referencias, les dejo el Python Visualizer para ver como se comporta nuestro codigo. 😁😁😁😁😁😁
http://www.pythontutor.com/visualize.html#mode=edit 💻

Les dejo varias formas de implementar fibonacci (no documenté las funciones)

from functools import lru_cache
import time

def fibonacci(n):
    if n == 0 or n == 1:
        return 1

    return fibonacci(n - 1) + fibonacci(n - 2)

@lru_cache(maxsize = 1000)
def fibonacci_lru(n):
    #Check that the input is a positive integer
    if type(n) != int:
        raise TypeError("n must be a positive int")
    if n < 1:
        raise ValueError("n must be a positive int")

    if n == 1:
        return 1
    elif n == 2:
        return 1
    elif n > 2:
        return fibonacci(n-1) + fibonacci(n-2)
    
#Using memoization
fibonacci_cache = {}

def fibonacci_memo(n):
    #If we have cached the value, return it
    if n in fibonacci_cache:
        return fibonacci_cache[n]

    #Compute the Nth term
    if n == 1:
        value = 1
    elif n == 2:
        value = 1
    elif n > 2:
        value = fibonacci(n-1) + fibonacci(n-2)

    #Cache the value and return iter
    fibonacci_cache[n] = value
    return value


def run():
    n = int(input("Cantidad de elemento de la sucesión: "))
    opcion = int(input("""Ingresa la opción:
                       1. Fibonacci (normalito)
                       2. Fibonacci (decoradores)
                       3. Fibonacci (Memoization)
                       """))
    inicial = time.time()
    if opcion == 1:
        for i in range(1, n+1):
            print(f'Elemento {i}: {fibonacci(i)}')
        print(f"Tiempo: {time.time()-inicial}")
    elif opcion == 2:
        for i in range(1, n+1):
            print(f'Elemento {i}: {fibonacci_lru(i)}')
        print(f"Tiempo: {time.time()-inicial}")
    elif opcion == 3:
        for i in range(1, n+1):
            print(f'Elemento {i}: {fibonacci_memo(i)}')
        print(f"Tiempo: {time.time()-inicial}")
    else:
        print("Es de 1 a 3. (╯°□°）╯︵ ┻━┻")
        

if __name__ == '__main__':
    run()

Recuerden que el primer paso para entender la recursividad es entender la recursividad

Aqui tienen un video donde explican, el metodo fibonacci de forma iterativa y recursiva es excelente tambien:

https://www.youtube.com/watch?v=4zFoXA8D8pA&ab_channel=MidiarioPython

Si alguno tiene dudas en cuanto al algoritmo de fibonacci esta explicacion esta muy buena y me ayudo a comprender mejor : https://www.youtube.com/watch?v=6_Y-2-50SSA

Hola , este es mi ejercicio de la sucesion fibonacci , lo entendi mejor de esta manera

def fibonacci():
    n = int(input('ingresa un numero de secuencia: '))

    num1, num2 = 0, 1  # caso base
    print(f'{num1}')
    print(f'{num2}')
    for i in range(n):
        num3 = num1+num2
        print(f'{num3}')
        num1 = num2  # 1
        # print(num1)
        num2 = num3  # num1+num2 1
       # print(num2)


fibonacci()```

# Function for nth fibonacci number - Space Optimisataion 
# Taking 1st two fibonacci numbers as 0 and 1 
  
def fibonacci(n): 
    a = 0
    b = 1
    if n < 0: 
        print("Incorrect input") 
    elif n == 0: 
        return a 
    elif n == 1: 
        return b 
    else: 
        for i in range(2,n): 
            c = a + b 
            a = b 
            b = c 
        return b 
  
# Driver Program 
  
print(fibonacci(9)) 
  

Hola amigos,
Buscando encontré esta otra definición recursiva, se trata de la sucesión de Lucas
Se definde la siguiente maner:

Y los resultados que se deberían obtener son los siguientes:

Lo implemente en Python (ya quisiera graficarlo), y acá les comparto el código:

def sucesion_lucas(numero):
    #print(numero) 
    if numero == 1:
        return 2
    elif numero == 2:
        return 1
    else:
         return sucesion_lucas(numero - 1) + sucesion_lucas(numero - 2)
    
numero = int(input('Un numero: '))
print(sucesion_lucas(numero))

😃

Hay veces en problemas de física cuántica, que aparecen ciertas funciones especiales, ciertos polinomios bonitos que contienen relaciones de recurrencia, que son, básicamente, relaciones recursivas, esto nos permite resolver un problema cuántico de manera computacional de modo eficiente, para más información, investiguen sobre los polinomios de Hermite o Lagrange 😄

Una problema que se da solución con recursividad es el famoso problema de las torres de hannoi.
Aquí les dejo un video donde explica que son las torres de hanoi.
https://www.youtube.com/watch?v=LM68IQvIo_E

“En los siguientes cursos de la serie de pensamiento computacional veremos como calcular exactamente la eficiencia de este algoritmo y cómo optimizarlo”
.

Así es como yo entiendo la recursividad en esta función:
![](

Háganme saber si me equivoqué en algo ❤️

Usando recursividad y más eficiente que el ejemplo de la clase:

def serie_fibonacci(cantidad_meses, mes=0, a=1, b=0):
    if mes <= cantidad_meses:
        print('Mes:', mes, '->', a + b)
        serie_fibonacci(cantidad_meses, mes + 1, b, a + b)


def main():
    print('Serie Fibonacci')
    mes = int(input('Digite la cantidad de meses: '))
    serie_fibonacci(mes)


if __name__ == "__main__":
    main()

Salida en pantalla para 10 meses:

Serie Fibonacci
Digite la cantidad de meses: 10
Mes: 0 -> 1
Mes: 1 -> 1
Mes: 2 -> 2
Mes: 3 -> 3
Mes: 4 -> 5
Mes: 5 -> 8
Mes: 6 -> 13
Mes: 7 -> 21
Mes: 8 -> 34
Mes: 9 -> 55
Mes: 10 -> 89

Otro ejemplo de llamada recursiva es el algoritmo de máximo común divisor:

def maximo_comun_divisor (m, n):
    """
    Calcula el maximo común divisor de m y n.
    m >= n > 0
    return maximo_comun_divisor.
    """
    if n == 0:
        return m
    return maximo_comun_divisor (n, m % n)

n = int(input('Escoge un número entero: '))
m = int(input('Escoge un número entero: '))

print(maximo_comun_divisor(m, n))```

En algunas fuentes de información les saldrá que fibonacci es 0, 1, 1, 2, 3, 5, 8, 13 y no 1, 1, 2, 3, 5, 8, 13
Esto es muy confuso aveces.
En aplicaciones donde tienen retos de programación les saldrá con el 0 y para solucionar este inconveniente en el código es cambiar el return = 1 por return = n:

def fibonacci(n):
    If n == 0 or n == 1:
        return n

    return fibonacci(n - 1) + fibonacci(n - 2)```

😄 Por si se lo preguntaban aquí está la cómo calcular e imprimir los números de la serie de Fibonacci:

def fibonacci(n):

    if n <= 1:
        return n
    else:
        return(fibonacci(n - 1) + fibonacci(n - 2))


n = int(input('Escribe hasta que número se calculará la serie de Fibonacci: '))
for i in range(n+1):
    print(fibonacci(i))

Sería bueno corregir varios detalles en este ejercicio que no llevan a la solución correcta. Se pudo haber elegido un ejemplo más natural y menos complicado.
…y por si alguien escribe un valor negativo, se requiere una validación extra

def fibo(n):
    if n <= 0:
        return 0
    if n == 1:
        return 1
    return fibo(n - 1) + fibo(n - 2)

La sucesión de Fibonacci y la razón aúrea.
https://www.youtube.com/watch?v=yDyMSliKsxI
Un vídeo muy interesante con la ciencia que hay detrás de esta sucesión.

Hace 10 años me dejaron de tarea hacer la secuencia de Fibonacci pero en Java, encontré el ejercicio y lo transformé a Python, jaja
Obvio no es la mejor solución pero se las quería compartir

Así para que el usuario pueda elegir el mes del cálculo.

def fibonacci(n):
    if n == 0 or n == 1:
        return 1

    return fibonacci (n - 1) + fibonacci (n - 2)

n = int(input("Escriba el mes que desea conocer: "))
print (f'En el mes número {n} habrán {fibonacci(n)} conejos')```

Esto debió hacer sido un video

Aqui un ejemplo con sumatoria.

def sumatoria(n):
""“Calcula la sumatoria de n.
n int>=0
returns sumatoria(n)
”""
if n == 1:
return 1
return n + sumatoria(n - 1)
n= int(input('Escribe un entero: '))
print(sumatoria(n))

Quedo claro!! … a la espera de ver como optimizar código.

Buena herramienta, solo que si me cuesta un poco entender en que casos prácticos o mas complejos usarlo.

La tabla en la que se describe el comportamiento de crecimiento para la camada de conejos esta mal, deberían corregirlo, pero si gustan corroborar, pueden usar específicamente la ecuación descrita de forma manual para descubrir los valores por mes que debería estar en la tabla.

Por ejemplo si: mes n > 1
tomamos el mes numero 2 y reemplazamos en la formula

F(n) = (n-1)+(n-2)
F(2) = (2-1)+(2-2)
entonces
F(2) = 1

que quiere decir esto, que como bien comprende el planteamiento del problema en el primer mes no vamos a encontrar hembras debido a que debe pasar un mes para que la primera hembra pueda tener una nueva pareja de conejos, por lo tanto en el mes 0 tenemos 0 hembras, eso quiere decir que los valores están desajustados por un mes entero de calculo.

Bueno al menos creo que es así.

si estoy mal espero alguien me pueda ayudar.

Básicamente una definición recursiva es cualquier función que tenga una variable que esté cambiando de valor en cada iteración, entendí bien?

Tengo duda acerca del código del ejemplo:

def fibonacci(n):
    if n == 0 or n == 1:
        return 1

    return fibonacci(n - 1) + fibonacci(n - 2)

¿No debería ser?:
if n == 0 o n == 1:
return n

Esto es un pequeño aporte sobre Fibonacci

def fibonacci(n):
    resultado = 0
    res = 0
    for i in range(1, n+1):
        if i == 1:
            res1 = 0
            res2 = 0
            resultado = 0
        elif i <= 3:
            res1 = 0
            res2 = 1
            resultado = 1
        else:
            res = res1 + res2
            res2 = res1
            res1 = res
            resultado = resultado + res
    return(resultado)

print(fibonacci(3))

Hola, yo tenia un poco de problemas para entender la recursividad, pero encontré estas diapos que explican de manera gráfica la recursividad. A mi me sirvió mucho, espero a alguien le sirva también. Saludos :3

Si necesitan reforzar el concepto de recursividad, pueden ver este video, aquí vas a apreciar los mismos ejemplos que se presentan en este curso

La recursividad de manera gráfica. Espero pueda ayudar a alguien a entender un poco mejor lo que sucede.

Aqui dejo una funcion para calcular el n-simo numero de Fibonacci mejor optimizada

def fibonacci(n):
    n1, n2 = 0, 1
    for i in range(n-1):
        aux = n1 + n2
        n1 = n2
        n2 = aux
    return n2

Aquí os dejo otra funcion que retorna una lista con los numeros de Fibonacci hasta el n-simo.
Lo logra mediante la memoizacion.
“En Informática, el término memoización (del inglés memoization) es una técnica de optimización que se usa principalmente para acelerar los tiempos de cálculo, almacenando los resultados de la llamada a una subrutina en una memoria intermedia o búfer y devolviendo esos mismos valores cuando se llame de nuevo a la subrutina o función con los mismos parámetros” (https://es.wikipedia.org/wiki/Memoización)

def memo_fibonacci(n, memo=None):
    if memo == None:
        memo = [0, 1, 1, 2]
    
    for i in range(n+1):
        if i > len(memo)-1:
            memo.append(memo[i-1] + memo[i-2])
        else:
            continue

    return memo

La sucesión de gradiente combinatorio es otro ejemplo de recursividad.

La fórmula es: Nn+1 = Cn + Rn

A partir de ella se pueden obtener las dos siguientes:

Rn = Nn+1 – Cn ; Cn = Rn+1 – Rn

A partir de una demostración se obtiene que Nn+1 = Rn+1
Debido a lo cual, la fórmula Cn = Rn+1 – Rn se puede reescribir de la siguiente forma: Cn = Nn+1 – Rn

Donde:

Nn+1: Número de combinaciones dobles sin repetición y/o permutación. El subíndice n representa la cantidad de colores y/o diseños pertenecientes a determinado conjunto, y es un número natural a partir de cero. Aunque, en ese caso, obviamente no habría ningún resultado de alguna combinación doble, pues N0+1 = N1 = 0, esto, por el hecho de que la sucesión de gradiente combinatorio solamente toma en cuenta las combinaciones dobles, es decir, las que se pueden agrupar en pares o de dos en dos, obtenidas, como mínimo, de entre un conjunto formado por dos o más elementos. A modo de ejemplo, N1+1= N2, se lee así: el número de combinaciones dobles sin repetición y/o permutación entre los elementos de un conjunto formado por dos colores o diseños es igual a…y así correspondientemente.

El factor positivo +1 significa que, con cada suma obtenida con los sumandos Cn + Rn, se encuentra la cantidad total de combinaciones sin repetición y/o permutación del siguiente conjunto de colores y/o diseños, siempre y cuando este aumente en la cantidad de uno respecto al anterior (ver tabla 9). Por patrón, se tiene que: N1 = C1 + R1 = R2 ; N2 = C2 + R2 = R3 ; N3 = C3 + R3 = R4 , y así sucesivamente; por lo que la fórmula desarrollada es la siguiente: Nn+1 = Cn + Rn . En consecuencia, se cumple con la siguiente condición: Nn+1 = Rn+1

Cn: Cantidad de colores o diseños de un conjunto. Para facilitar los cálculos se recomienda asignar números naturales consecutivos a cada conjunto de colores y/o diseños, como se observa en la columna izquierda de la tabla 9.

Rn: Resultado de la cantidad de combinaciones dobles sin repetición y/o permutación entre los elementos de Cn.

Colores o diseños Número de combinaciones
C1=1 R1=0
C2=2 R2=1
C3=3 R3=3
C4=4 R4=6
C5=5 R5=10
C6=6 R6=15
C7=7 R7=21
C8=8 R8=28

**Nota:
En este ejemplo se usa la fórmula de gradiente combinatorio para colores y/o diseños de ropa pero se puede aplicar para conjuntos formados por otros tipos de elementos.
**

def run():
    pass


def fibonacci(n):
    if n == 0 or n == 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)
n = int(input("Ingrese un Numero: "))
print(f' El fibonacci de {n} es {fibonacci(n)}')

if __name__ == '__main__':
    run()

Otra de las funciones recursivas que existen en las matemáticas es el determinante de una matriz por el método de cofactores y uno de mis métodos de ordenamiento favoritos igual se logra con recursividad: Ordenamiento Quicksort.

def fibonacci(n):
if n0 or n1:
return 1

return fibonacci(n-1) + fibonacci(n-2)

n = int(input('En cuál mes desea saber: ‘))
print(f’En el mes {n} habrá {fibonacci(n)} conejos’)

Genial realice una pequeña modificación al código.

def fibonacci(n):
    if n == 0:
	return 1
    elif n < 4:
        return n
    else
       return fibonacci(n - 1) + fibonacci(n - 2)

Muy interesante y fundamental, aquí un video para poder ampliar y entender un poco más

https://www.youtube.com/watch?v=sY0HYpU2cwk

def fibonacci():

    """ Serie Fibonacci
    recibe un numero entero

    """
    n = int(input('Digite un numero entero'))

    a =0
    b=1

    for i in range(n):

        print(a)

        c=a+b
        a=b
        b=c

if __name__ =='__main__':
    
    fibonacci()

Entendí el funcionamiento código y como funciona Faccionario
Lo que no entiendo es la formula de fibonacci(n-1) + fibonacci(n-2). Ayuda

def fibonacci(n):
    if n < 2:
        return n
    else:
        return fibonacci(n-2) + fibonacci(n-1)


if __name__ == '__main__':
    n = int(input('Dame un numero para calcular: '))
    for i in range(n):
        print(fibonacci(i+1))

Dice que los conejos se pueden reproducir hasta la edad de 1 mes. Mas adelante dice que la hembra siempre es capaz de producir una nueva pareja. Entiendo el concepto de fibonacci pero el ejemplo lo encuentro confuso. Quizás no lo entendí bien simplemente pero aprovecho de manifestar mi inquietud.

Asi fue como hice para poder ver todos los numeros de la serie y no solo uno

def fibonachi(n):

   
    if n <=1:
        return n

    else:
        return fibonachi(n-1) + fibonachi(n-2)

    
print('¿ T E  F I B O N A C H E O   U N   N U M E R O ?')
n = int(input('Dime el numero:'))


while n >=1:
    print(fibonachi(n))
    n -= 1```

def fibonacci(n): 
    """Calcula la seria fibonacci 
    """
    
    if n == 0 or n == 1: 
        return 1 

    return fibonacci(n - 1) + fibonacci(n - 2)  

n = int(input('Escribe un entero: '))

print(fibonacci(n)) 


 

Yo uso esta función recursiva para obtener un número desde la consola, y mientras haya un error en el dato ingresado, vuelve a ejecutarse

def get_number():
    try:
        return int(input('Ingresa un número: '))
    except:
        return get_number() 

Al principio no sabia que hacia mi funcion, me toco volver a lapiz y papel para saber que estaba haciendo

def fibonacci(n):
    if n == 0 or n == 1:
        return 1

    return fibonacci(n - 1) + fibonacci(n - 2)

fibonacci(5)

Que interesante había escuchado hablar sobre la secuencia de Fibonnacci pero nunca se me ocurrió que se podría llegar a utilizar en programación.

Cuenta regresiva hasta cero a partir de un número

def cuenta_atras(num):
num -= 1
if num > 0:
print(num)
cuenta_atras(num)
else:
print(“Fin de la función”, num)

cuenta_atras(5)

Sumatoria de números naturales desde 1 hasta n:

Acá mi código

def fibonacci(n):
    """Calcula el la secuencia de fibonacci de n

        n int > 1
        returns (n - 1) + (n -2)
    """
    print(n)
    if n == 0 or n == 1:
        return 1

    return fibonacci(n - 1) + fibonacci(n - 2)

if __name__ == '__main__':
    n = int(input('Escriba un entero: '))

    print(fibonacci(n))

def fibonacci(n):
    """Calcula la secuencia fibonacci de n

    n int > 1
    returns (n-1) + (n-2)
    """
    print(n)
    if n == 1 or n == 0:
        return 1

    return fibonacci(n - 1) + fibonacci(n - 2)

n = int(input('Escribe un entero: '))

print(fibonacci(n))```

def fibinacci(x,y,z,fin):
    while z < fin:
        print(z)
        z = x + y
        x = y
        y = z        

number = int(input('Ingresa final de finacacci: '))
fibinacci(x=0,y=1,z=1,fin=number)

def fibonacci(number):
    """
        Calcular el factorial de la variable n

        number int > 0
        retrurn number factorial
    """
    print(number)
    if number == 0 or number == 1:
        return 1

    return fibonacci(number - 1) + fibonacci(number - 2)


if __name__ == '__main__':
    number = int(input('Escribe un número: '))

    result = fibonacci(number)

    print('La serie Fibonacci de {} es {}'.format(number, result))

Esta es una funcion que hice pero mas concreta al tema de los conejos, espero puedan comentar que les parece

def calc_female_rabbit_population(rabbits, total_months, current_month = 0, reprod_rabbits = 0):
    """Calcula la populacion de conejas en un lapso de tiempo

    rabbits int cantidad de conejos > 0
    total_months int lapso de tiempo en meses
    current_month int el mes actual
    reprod_rabbits int conejas que pueden reproducirse
    """
    current_status = [f"Month {current_month} with {rabbits} rabbits"]
    if current_month == total_months:
        return current_status
    else:
        new_rabbits = reprod_rabbits + rabbits if reprod_rabbits > 0 else 1
        new_reprod_rabbits = reprod_rabbits + (rabbits - reprod_rabbits)
        return current_status + calc_female_rabbit_population(new_rabbits, total_months, (current_month + 1), new_reprod_rabbits)

results = calc_female_rabbit_population(1, 6)
for result in results:
    print(result)

Me encanta la aplicabilidad en todas las áreas de la vida de esta secuencia Y a nivel de código, al ser recursivo es sumamente corto

Me tomo algo de tiempo entenderlo así que comparto explicación a mi manera de enteder.

Comenzamos con 0(a) , 1(b)
luego sumas 0 + 1 = 1(a nuevo)
ahora con el nuevo (a) se lo sumas al (b) antiguo:
1(a nuevo) + 1(b antiguo) = 2(b nuevo)
y obtienes 1(a), 2(b) = 1, 2
asi sucesivamente
1 + 2 = 3
3 +2 = 5
3, 5
3 + 5 = 8
8 + 5 = 13
8, 13
espero que a alguien le sirva

mi solución de acuerdo a lo que introduzca el usuario el programa va a generar la determinada cantidad de números que da la sucesión.

Para entender la función de Fibonacci, me encantó esta explicación de ChatGPT:

F(0) = 0
F(1) = 1
F(n) = F(n-1) + F(n-2) para n >= 2

Aquí, F(n) representa el n-ésimo número en la secuencia de Fibonacci. Por ejemplo, F(0) es el primer número (0), F(1) es el segundo número (1), F(2) es el tercer número (1), F(3) es el cuarto número (2), y así sucesivamente.

Para calcular un término específico de la serie, necesitas aplicar la fórmula F(n) = F(n-1) + F(n-2) sucesivamente, comenzando con los valores iniciales de F(0) y F(1). ****Por ejemplo, para encontrar el sexto número de Fibonacci (F(5)), ****debes sumar F(4) y F(3):

F(5) = F(4) + F(3)
= (F(3) + F(2)) + (F(2) + F(1))
= ((F(2) + F(1)) + (F(1) + F(0))) + (F(1) + F(0))
= ((1 + 1) + (1 + 0)) + (1 + 0)
= 5

Por lo tanto, el sexto número de Fibonacci es 5. Puedes continuar este proceso para calcular términos adicionales de la serie.

Costo entender, pero gracias a los recursos mucho mejor, el siguiente curso debe ser bueno.

Impresión de la secuencia de Fibonacci

def fibonacci(n):
    if n == 0 or n == 1:
        return 1
    return fibonacci(n-1) + fibonacci(n-2)

n = 0
index = 0

while n < 1:    
    try:
        n = int(input('Escribe el valor de N para el cálculo de Fibonacci: '))
    except ValueError:
        n = 0
        
# Se imprime la secuencia
while index < n:
    print(fibonacci(index))
    index += 1

The magic of Fibonacci numbers | Arthur Benjamin

Genial!

javaScript ❤️

function fibonacci(n) {
if(n == 0 || n == 1){
return 1
};
return fibonacci(n - 1) + fibonacci(n - 2)
};

console.log(fibonacci(5))