Sucesión de Fibonacci con Groovy

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 Groovy es muy sencillo y tan solo ocupa un total de 19 líneas de código, es interactivo ya que le permite al usuario el límite de números de la sucesión.

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

Scanner input = new Scanner(System.in)
def aux = 1L, fib = 0L, lim, init = 0

println(_INFO)
print("Ingrese un numero para la sucesion de fibonacci: ")
lim = input.nextLong()

if(lim > 0) {
    (1L..lim).each { print("[$fib] ")
        aux += fib
        fib = aux - fib
    }
} else {
    println("El numero debe ser mayor a cero!!")
}
println()

Groovy es parte de la familia de lenguajes cuya sintaxis es muy sencilla tanto para programadores avanzados como para principiantes mejorando la legibilidad del código, el programador entenderá rápidamente cada una de las líneas de código en un programa cuando se lee código ajeno o ayudándolo a ser más productivo.

Declarando e inicializando variables:

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

Scanner input = new Scanner(System.in)
def aux = 1L, fib = 0L, lim, init = 0, prb = 0L, nrm = 0L

En Groovy hay 2 formas para declarar las variables, la primera es la forma dinámica y la segunda es la forma estática. La forma dinámica funciona igual que en otros lenguajes dinámicos como Python, Ruby o PHP, las variables no están atadas a un tipo de dato fijo, permitiendo almacenar valores de diferentes tipos. Por otro lado, en la forma estática, las variables que son declaradas con un tipo (ej: String), no pueden almacenar un valor de un tipo diferente y en caso de almacenar un entero, se convierte a String.

En este fragmento de código se hace uso de ambas formas, tanto dinámica como estática. En la primera y última línea se declaran 7 variables de forma dinámica usando la palabra clave def, en la primera línea la variable contiene un String y está escrita en mayúscula para simular una “constante”, mientras que en la última línea se crean 6 variables en las cuales 5 son de tipo Long inicializadas con los valores 0 y 1. en la última línea 4 se crea un objeto de tipo Scanner() de forma estática llamado input usando la palabra clave new, anteponiendo el tipo de dato que en este caso es Scanner a la variable.

Procesos internos del programa, mostrando la Sucesión de Fibonacci:

if(lim > 0) {
    (1L..lim).each { print("[$fib] ")
        aux += fib
        fib = aux - fib
    }
} else {
    println("El numero debe ser mayor a cero!!")
}

Debido a que la cantidad de números de la Sucesión de Fibonacci a mostrar van en un rango desde 1 hasta N, es decir, si queremos mostrar los 10 primeros 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 necesita que una sentencia if() verifique que N sea mayor a 0, garantizando el correcto procesamiento de la información sólo si se cumple dicha condición.

La Closure .each {} es un iterador que va a recorrer un rango desde 1 hasta Lim, siendo este último el límite superior de números que se mostraran; mientras que en su interior hay una función print() que imprime cada número Fibonacci encerrado entre [..] y dos operaciones 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 es cero o menos a cero.

¿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.