Fibonacci¶

La sucesión de Fibonacci comienza con los dos primeros valores que son 0 y 1.
El resto de los términos se obtiene sumando los dos anteriores.
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, ...

Método 1¶

Solicitamos al usuario que nos indique el número de elementos de la sucesión que desea generar.
Establecemos en 5 el número mínimo de elementos a mostrar.
Usamos la función max para que si el usuario nos proporciona un número menor a 5, se establezca n igual a 5.

In [ ]:

n = max(int(input('¿Cuántos valores quieres? (minimo 5): ')), 5)
a = 0
b = 1
print(a)
print(b)
for i in range(0, n-2):
    aux = a + b   # usamos una variable auxiliar para obtener el siguiente valor de la serie
    print(aux)
    a = b
    b = aux

¿Cuántos valores quieres? (minimo 5): 20
0
1
1
2
3
5
8
13
21
34
55
89
144
233
377
610
987
1597
2584
4181

Método 2¶

Con una estructura while True solicitamos el valor de n, que se continuará preguntando hasta que el usuario introduzca un valor mayor que dos.
Trabajamos con listas donde los dos primeros elementos vienen dados y son 0 y 1.
Los restantes elementos se generan sumando los dos previos y se añaden a la lista con append.

In [ ]:

while True:
    n=int(input('¿Cuántos valores quieres? (mínimo 3): '))
    if n > 2:
        break
x = [0,1]
for i in range(n-2):
    x.append(x[-1] + x[-2])
print(x)

¿Cuántos valores quieres? (mínimo 3): 20
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181]

Método 3¶

Trabajamos con una lista que inicializamos con los dos primeros valores 0 y 1.
Nos metemos en un bucle for dentro del cual usamos append para ir añadiendo elementos nuevos a la sucesión de Fibonacci.

In [ ]:

lista = [0, 1]
for i in range(3, 21):
    lista.append(lista[len(lista)-1] + lista[len(lista)-2])
print(lista)

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181]

Método 4¶

Trabajamos con una función dentro de la cual inicializamos las variables a y b con los valores 0 y 1 respectivamente.
Nos metemos en un bucle for donde creamos una tercera variable auxiliar c que será la suma de a+b.

In [ ]:

def fibo(n):
    a, b = 0, 1
    for i in range(3, n+1):
        c = a + b
        a = b
        b = c
    return(c)
print(fibo(100))

218922995834555169026

Método 5¶

Trabajamos con una lista llamada fibo que vamos alimentando con append a cada ciclo de bucle for.

In [ ]:

n = 20    # número de términos de la serie
fibo = [0, 1]
for i in range (n-2):
    fibo.append(fibo[-1] + fibo[-2])
print(fibo)

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181]

Método 6¶

Creamos una función a la que pasamos el parámetro n que nos indica el número de elementos de la sucesión de Fibonacci que deseamos.
Dentro de la función definimos las variables a y b con los valores 0 y 1 respectivamente.
Nos metemos en un bucle for que recorrerá los elementos que vamos a generar.`
Se imprime el valor de a y se deja un espacio vacío, evitando el retorno de carro.
Asignamos a la variable a el valor de b, y a la b el valor de a+b.
La última línea de código dentro de la función es un print() que equivale a un retorno de carro, pero permite imprimir el resultado.

In [ ]:

def fibo(n):
    a, b = 0, 1
    for i in range(n):
        print(a, end=' ')
        a, b = b, a+b
    print()
fibo(20)

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181

Método 7¶

Si te has preguntado cómo conseguir la sucesión de Fibonacci sin usar una variable auxiliar aquí tienes la solución.
Con este método evitamos tener que utilizar una variable auxiliar.

In [ ]:

n = 20
a, b = 0, 1
print("1:", a)
print("2:", b)

for i in range(3, n+1):
    b = a + b
    a = b - a  # así evitamos emplear una variable auxiliar
    print(f"{i}: {b}")

Método 8¶

Por recursión
Usando la recursividad
Es importante establecer la condición de parada.
La condición de parada, cuando es cierta, permite resolver el algoritmo directamente.
La llamada recursiva permite resolver el problema cuando la resolución no es directa.
La función se va llamando a si misma hasta que se llega al final que es la condición de parada
La regla recursiva viene dada por la siguiente expresión.

$$fibonacci(n) = \left\lbrace\begin{array}{c} 0~& si~n=1 \\ 1~& si~n=2 \\ fibonacci(n-1) + fibonacci(n-2) ~& si~n>2 \end{array}\right.$$

In [ ]:

def fibo(n):
    if n <= 1:                          # condición de parada o "caso base"
        return n
    else:
        return(fibo(n-1) + fibo(n-2))   # "caso recursivo"

n = 20

for i in range(n):                     # i va de 0 a n-1
    print(f"{i+1} → {fibo(i)}")

Método 9¶

Una variante del caso anterior
Usando también la recursividad

In [ ]:

def fibo(n):
    if n in {0, 1}:
        return n
    return fibo(n-1) + fibo(n-2)

n = 19

[fibo(i) for i in range(n)]

Out[ ]:

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584]

Método 10¶

Elegancia con un while.

In [3]:

a, b = 0, 1
while a < 100:
    print(a)
    a, b = b, a+b