Aula 17 – Tutorial Golang – Recursão
Aula 17 – Tutorial Golang – Recursão
Tutorial Golang – Recursão
Página principal do blog
Todas as aulas desse curso
Aula 16 Aula 18
Se gostarem do conteúdo dêem um joinha 👍 na página do Código Fluente no
Facebook
Esse é o link do código fluente no Pinterest
Meus links de afiliados:
Hostinger
Digital Ocean
One.com
Melhore seu NETWORKING
https://digitalinnovation.one/
Participe de comunidades de desenvolvedores:
Fiquem a vontade para me adicionar ao linkedin.
E também para me seguir no https://github.com/toticavalcanti.
Código final da aula:
https://github.com/toticavalcanti
Toti:
https://www.youtube.com/channel/UCUEtjLuDpcOvR3mIUr-viOA
Backing track / Play-along:
https://www.youtube.com/channel/UCT3TryVMqTqYBjf5g5WAHfA
Código Fluente
https://www.youtube.com/channel/UCgn-O-88XBAwdG9gUWkkb0w
Putz!
https://www.youtube.com/channel/UCZXop2-CECwyFYmHbhnAkAw
PIX para doações
PIX Nubank
Se quiser copiar o código do PIX:
00020126580014BR.GOV.BCB.PIX013643c5f950-535b-4658-b91f-1f1d135fe4105204000053039865802BR5925Antonio Cavalcante de Pau6009SAO PAULO61080540900062070503***6304946B
Aula 17 – Tutorial Golang – Recursão
Recursão
Em ciência da computação, a recursão é uma forma de resolver problemas em que a solução depende de soluções de instâncias menores do problema maior.
Esses problemas geralmente podem ser resolvidos por iteração, mas é necessário identificar e indexar as instâncias menores no momento da programação.
A recursão resolve esses problemas usando funções que chama a si mesma de dentro de seu próprio código.
A abordagem pode ser aplicada a muitos tipos de problemas, e a recursão é uma das ideias centrais da ciência da computação.
Go oferece suporte a funções recursivas.
Vamos a um exemplo clássico do fatorial de um número.
Essa função de fato chama a si mesma até atingir o caso base de fato (0).
func fact(n int) int {
if n == 0 {
return 1
}
return n * fact(n-1)
}
Na primeira o n é 5, e como ele não sabe o resultado ele chama com n – 1 = 4, só que a função ainda não tem como saber o fatorial de 4, então a função é chamada mais uma vez, agora com 3.
Recursividade fatorial de 5 figura inicial
E assim vai até chegar o caso base, que é o 1.
Recursividade fatorial de 5 figura final
Como no caso base a função sabe o resultado, que é 1, ela retorna para chamada anterior, a do n = 2, fazendo:
n * fact(n-1) = 2 * 1 = 2, que é o resultado da chamada do n = 2, aí então esse 2 de resultado é retornado para a chamada da 3, fazendo 2 * 3 = 6, e assim vai até desempilhar todas as chamadas e ter o resultado final do fatorial do n inicial.
Na aula https://www.codigofluente.com.br/aula-06-subsequencia-comum-mais-longa-lcs/ tem uma explicação mais detalhada.
Recursão com Closure
Os closures também podem ser recursivas, mas, isso requer que ela seja declarada com uma var digitada explicitamente antes de ser definida.
Exemplo de recursão usando closure, isto é, função anônima, para achar o n-ésimo número da sequência de Fibonnaci.
//declara uma variável do tipo função anônima(closure)
//que recebe um parâmetro do tipo inteiro e retorna um inteiro
var fib func(n int) int
//usa a variável criada anteriormente para receber o retorno
//da implementação da função anônima fib
fib = func(n int) int {
if n < 2 {
return n
}
return fib(n-1) + fib(n-2)
}O código acima tá dentro da função main().
Código completo
package main
import "fmt"
func fact(n int) int {
if n < 2 {
//caso base
return 1
}
return n * fact(n-1)
}
func main() {
//declara uma variável do tipo função anônima(closure)
//que recebe um parâmetro do tipo inteiro e retorna um inteiro
var fib func(n int) int
//usa a variável criada anteriormente para receber o retorno
//da implementação da função anônima fib
fib = func(n int) int {
if n < 2 {
return n
}
return fib(n-1) + fib(n-2)
}
//imprime os resultados
fmt.Println("O fatorial de 7 é:", fact(7))
fmt.Println("O sétimo número da sequência de Fibonnaci é:", fib(7))
}
E pra executar é só entrar na pasta onde tá o arquivo recursion.go e digitar:
go run recursion.go
