Sucesión de Fibonacci con Go

La Sucesión de Fibonacci es una sucesión de números enteros iniciando con dos números base, 0 y 1. Cada número de la sucesión es el resultado de la suma de los dos anteriores; por ejemplo:

[0] [1] [1] [2] [3] [5] [8] [13] [21] [34]

Esta Sucesión de Fibonacci solo muestra 10 números y se observa cómo se genera cada número sumando los dos números anteriores, es decir: 0 + 1 = 1, 1 + 1 = 2, 1 + 2 = 3, 2 + 3 = 5… hasta 13 + 21 = 34…

Código fuente:

El programa que nos permite generar la Sucesión de Fibonacci en Go es muy sencillo y tan solo ocupa un total de 26 líneas de código, es interactivo ya que le permite al usuario el límite de números de la sucesión.

package main

import "fmt"

const INFO = "Este programa imprime la sucesion de fibonacci desde 1 hasta N," + 
"\nsiendo este ultimo un numero ingresado por el usuario\n"

func main(){
  var aux, fib int64 = 1, 0
  var lim, init int64
  
  fmt.Println(INFO)
  fmt.Print("Ingrese un numero para la sucesion de fibonacci: ")
  fmt.Scanf("%d", &lim)
  
  if lim > 0 {
      for init = 1; init <= lim; init++ {
        fmt.Printf("[%d] ",fib)
        aux += fib
        fib = aux - fib
      }
  } else {
      fmt.Println("El numero debe ser mayor a cero!!")
  }
  fmt.Println()
}

En Go la sentencia package es obligatoria junto con el nombre del paquete, este nombre servirá para que dicho paquete se pueda importar desde otros archivos fuentes; mientras que por otro lado, el nombre del paquete que es ejecutable debe llamarse main. La sentencia import nos permite importar los paquetes que necesitemos para trabajar, si la cantidad de paquetes es bastante entonces podemos encerrarlos entre (…) para evitar escribir demasiados imports, de la siguiente forma:

import (
    "ftm"
    "paquete2"
    "paquete3"
    ...
)

Una constante con informaion al usuario, const:

const INFO = "Este programa imprime la sucesion de fibonacci desde 1 hasta N," + 
"\nsiendo este ultimo un numero ingresado por el usuario\n"

En este fragmento de código se crea una constante llamada INFO la cual contiene un string multilínea. Las constantes en Go se crean con la palabra clave const, excepto que no requiere llevar el tipo de dato como string, int, long u otros ya que son inferidos desde el contexto.

Creando las variables necesarias:

var aux, fib int64 = 1, 0
var lim, init int64

Se crean 4 variables, todas de tipo int64, de las cuales las 2 primeras se inicializan con los valores 1 y 0 usando asignación múltiple. En la primera línea se pudo haber omitido también el tipo ya que Go posee inferencia de tipos desde el contexto de acuerdo al valor asignado. Otra forma de crear variables es usando el operador :=, de la siguiente forma aux, fib := 1, 0 sin la palabra var y solo se puede usar dentro de funciones.

Mostrando información y leyendo datos por teclado, Print y Scanf:

fmt.Println(INFO)
fmt.Print("Ingrese un numero para la sucesion de fibonacci: ")
fmt.Scanf("%d", &lim)

El programa imprime en pantalla, usando la función Println(), el mensaje almacenado en la variable INFO y un mensaje que le dice al usuario que ingrese un número para procesar. El dato ingresado por el usuario es leído usando la función Scanf(), el primer parámetro es el string “%d” ya que el dato a leer es un número decimal; mientras que separado por una coma se pasa por referencia (usando el signo “&”) la variable en donde será guardado el dato. Hay un detalle en este fragmento de código, ambas funciones se preceden con “fmt” que corresponde al nombre del paquete importado.

Sentencia if y proceso interno:

if lim > 0 {
    for init = 1; init <= lim; init++ {
        fmt.Printf("[%d] ",fib)
        aux += fib
        fib = aux - fib
    }
} else {
    fmt.Println("El numero debe ser mayor a cero!!")
}

Cabe recordar que el rango de los números de la Sucesión que se muestran van desde 1 hasta N, es decir, si vamos a mostrar 10 números de la sucesión como se hizo al inicio, se requiere de un bucle que vaya desde 1 hasta N; por lo tanto se requiere que N sea mayor a 0, esto se garantiza con una sentencia if que verifique si se cumple con este requisito para procesar la información.

El bucle for va a iterar desde 1 hasta lim, siendo este ultimo el limite superior de numeros que se mostraran; en su interior hay una función Printf() que imprime cada número Fibonacci encerrado entre [..] y hay dos operaciones aritméticas básicas, la primera corresponde a la suma abreviada de aux += fib en la línea #4 que es equivalente a escribir aux = aux + fib el cual suma el valor en aux y fib, y luego lo agina a aux, ambas formas son válidas; la segunda, en la línea #4, es una resta entre aux y fib sin abreviación ya que aux siempre será mayor que fib. Por último aparece la variable init que se incrementa en +1 en cada iteración.

La sentencia else solo emite un mensaje en caso de que el número ingresado por el usuario sea igual o menor a cero o en caso contrario, que sea un carácter o string.

¿Como funciona internamente las operaciones aritméticas?:

Como se describe arriba, hay dos operaciones aritméticas básicas, la primera es una suma y la segunda es una resta; pero, ¿cómo funcionan tras bambalinas? Aquí veremos lo que ocurre con cada operación.

Primera operación aritmética, aux += fibo aux = aux + fib:

Para ilustrar lo que ocurre con esta primera operación aritmética, he modificado el código para imprimir una tabla que nos muestre con mayor detalles los cambios en las variables con cada iteración.

Ingrese un numero para la sucesion de fibonacci: 10
|	Valores iniciales	| = |	nuevo valor de Aux	|
|	Fib		Aux	|   |	     aux += fib		|
|	[0]	+	[1]	| = |		[1]		|
|	[1]	+	[1]	| = |		[2]		|
|	[1]	+	[2]	| = |		[3]		|
|	[2]	+	[3]	| = |		[5]		|
|	[3]	+	[5]	| = |		[8]		|
|	[5]	+	[8]	| = |		[13]		|
|	[8]	+	[13]	| = |		[21]		|
|	[13]	+	[21]	| = |		[34]		|
|	[21]	+	[34]	| = |		[55]		|
|	[34]	+	[55]	| = |		[89]		|

Al inicio de esta publicación se dijo que la serie inicia con 2 números base, 0 y 1. Al lado izquierdo de la tabla se muestra que Fib tiene como valor inicial 0 mientras que Aux tiene como valor inicial 1; al lado derecho se muestra cada cambio en el valor de la variable Aux después de la suma hecha en cada iteración.

Segunda operacion aritmetica, fib = aux - fib:

Para ilustrar lo que ocurre con esta segunda operación aritmética, he modificado nuevamente el código para imprimir una tabla que nos muestre con mayor detalles los cambios en las variables con cada iteración.

Ingrese un numero para la sucesion de fibonacci: 10 
|	  fib = aux - fib	| = |  Resultado de la Sucesion	|
|	Aux		Fib	|   |	   Numero Fibonacci	|
|	[1]	-	[1]	| = |		[0]		|
|	[2]	-	[1]	| = |		[1]		|
|	[3]	-	[2]	| = |		[1]		|
|	[5]	-	[3]	| = |		[2]		|
|	[8]	-	[5]	| = |		[3]		|
|	[13]	-	[8]	| = |		[5]		|
|	[21]	-	[13]	| = |		[8]		|
|	[34]	-	[21]	| = |		[13]		|
|	[55]	-	[34]	| = |		[21]		|
|	[89]	-	[55]	| = |		[34]		|

Con la anterior operación aritmética se altera el valor de la variable aux, se dijo que este valor es mayor que el valor de fib y la tabla nos muestra que efectivamente si es así; excepto en los primeros valores cuyo valor es igual. Al realizar la resta entre aux y fib nos da como resultado el valor del número Fibonacci; este resultado coincide con el valor de la variable fib en la tabla de la anterior operación.