Sucesión de Fibonacci con Kotlin
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 Kotlin es muy sencillo y tan solo ocupa un total de 18 líneas de código, es interactivo ya que le permite al usuario el límite de números de la sucesión.
fun main(arg: Array<String>) {
var numVal: Long
var fib = 0L
var aux = 1L
print("Ingrese un numero para la sucesion de fibonacci: ")
numVal = readLine()!!.toLong()
if(numVal > 0) {
(1 .. numVal).forEach { print("[$fib] ")
aux += fib
fib = aux - fib
}
} else {
println("El numero debe ser mayor a cero!!")
}
println()
}
En Kotlin la sentencia package es opcional; pero es recomendado usar dicha sentencia asignando un nombre de paquete al archivo fuente cuando se trabaja en programas más grandes que serán divididos en diferentes archivos con el fin de facilitar la importación desde otros archivos fuente.
Declarando variables:
var numVal: Long var fib = 0L var aux = 1L
En Kotlin las variables se declaran con la palabra clave var como se observa en este fragmento de código, pero se ven mas detalles como la falta del tipo de dato en las 2 últimas variables y se debe a que el tipo se infiere. Esta es una característica de Kotlin, podemos omitir el tipo y se infiere desde el contexto. Las tres variables son de tipo Long, la primera de forma explícita mientras que las dos últimas se infieren desde el contexto agregando una “L” junto al valor.
readLine(), ingresando datos por teclado:
print("Ingrese un numero para la sucesion de fibonacci: ")
numVal = readLine()!!.toLong()
En este fragmento de código se realizan 2 tareas; la primera muestra un mensaje al usuario solicitando que ingrese un número, esta tarea la cumple la función print(); la segunda lee el numero ingresado por el usuario usando la función readLine() + la función .toLong() si la lectura falla entonces lanza una excepción.
Procesos internos del programa, mostrando la Sucesión de Fibonacci:
if(numVal > 0) {
(1 .. numVal).forEach { 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 función .forEach {} es un iterador que va a recorrer un rango desde 1 hasta numVal, siendo este último el límite superior de números que se van mostrar; mientras que en su interior hay una función println() 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 #3 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.
