Publicado por En esta ocasión estudiaremos dos pequeños conceptos que nos servirán para complementar lo que hemos visto en las entradas pasadas: la recursión y la conversión de tipo (type casting).
¿Qué es la recursión?
La recursión es un método de resolución de problemas por medio de su división en pequeñas instancias que luego son unidas para generar una solución global.
La recursión se comporta como una pila en la que se ingresan valores hasta alcanzar uno o varios casos base a partir de los cuales se solucionará el problema.
Los algoritmos recursivos constan de dos elementos fundamentales:
- Casos base: son los escenarios finales a partir de los cuales se comienzan a agrupar las pequeñas soluciones.
- Reglas: las cuales se encargan de dividir el problema principal en diversos casos.
Imaginemos que deseamos obtener una sumatoria desde i = 1 hasta i = 5. Una implementación recursiva sería la siguiente:
package main
import "fmt"
func sumatoria(tope int) int {
//Caso base
if tope == 1 {
return tope
}else{
//Suma tope a lo que regrese la recursión de tope - 1
return tope + sumatoria(tope - 1)
}
}
func main() {
tope := 10
fmt.Printf("La sumatoria hasta %d es: %d\n", tope, sumatoria(tope))
}
Salida:
El código anterior hace recursiones desde tope = 5 hasta alcanzar el caso base tope = 1. Después se desapilan los llamados devolviendo los valores correspondientes a la recursión actual. La siguiente imagen ilustra esta breve descripción:
El siguiente es un ejemplo de una función recursiva que imprime la serie de Fibonacci hasta la posición N:
package main
import "fmt"
func fibonacci(i int) int {
//Caso base
if(i == 0) {
return 0
}
//Otro caso base
if(i == 1) {
return 1
}
return fibonacci(i-1) + fibonacci(i-2)
}
func main() {
for n := 0; n < 15; n++ {
fmt.Printf("| %d ", fibonacci(n))
}
fmt.Printf("|\n")
}
Salida:
Conversión de tipo
La conversión de tipo (Type Casting es transformar momentáneamente una variable a un tipo diferente. En Golang esto se logra utilizando el nombre del tipo de dato objetivo, seguido de un par de paréntesis que encierren a la variable que deseamos convertir. Si tenemos una variable mi_variable tipo int16 y lo queremos convertir en int32, la sintaxis de conversión sería la siguiente:
int32(mi_variable)
Nota: recuerda que la conversión de tipo solamente funciona para realizar operaciones, no es posible cambiar permanentemente el tipo de ninguna variable. La sintaxis anterior es válida solamente si se usa para alguna operación.
El siguiente es un ejemplo de cómo se realiza una conversión para multiplicar variables de tipos distintos:
package main
import "fmt"
func main(){
var a uint16 = 120
var b uint32 = 3000
fmt.Println("Resultado axb: ", uint32(a)*b)
fmt.Println("Este es un resultado distinto: ", a*uint16(b))
}
Salida:
Nota: se puede apreciar que el segundo resultado es diferente al primero a pesar de que es la misma multiplicación. Esto sucede porque 120*3,000 = 360,000 y este número es mayor al valor máximo que puede representar un uint16.
Finalizando
En esta entrada hemos aprendido dos conceptos nuevos que complementan todo lo que hemos visto hasta ahora. No dejes de estar en sintonía, hasta la próxima, see ya!