14. Go to go: recursión y conversión de tipos

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:

  1. Casos base: son los escenarios finales a partir de los cuales se comienzan a agrupar las pequeñas soluciones.
  2. 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:

02-golang-recursion

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:

recursion

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:
01-golang-recursion

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:

01-golang-conversion

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!

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *