1

Três formas de Fatorizar um número em Kotlin

#Kotlin
Luís Amorim
Luís Amorim

Salve salve, galera! 👋


Trago mais uma de minhas sagas. Hoje adaptei o texto Three Ways to Factorialize a Number in JavaScript para Kotlin. Espero que possa ajudar de alguma forma.


Prefácio

Nesse texto veremos como fazer o fatorial de um número, então primeiramente veremos a definição de fatorial.



Fatorial Definição:

Seja n um número natural, o fatorial de n é definido por:

  • 0! = 1
  • n! = n * (n – 1)*(n – 2) … 3 * 2 * 1


Exemplo:

  • 0! = 1
  • 5! = 5 * 4 * 3 * 2 * 1 = 120

Tendo essa definição em mente, já podemos pensar sobre o algorítimo para fatorizar um número.


Usando uma função recursiva:

Mais uma vez utilizamos o método da função recursiva.

fun main(){
  fun fatoracao(num: Int): Int{
    //tirando os números negativos
  return if (num < 0){
   -1
 } else if (num == 0){ 
   1 //se n=0, fatoracao(0)=1 
 } else {
   num * fatoracao(num-1) //quando n>=1
 } 
/*
--- Primeira parte da função recursiva:
Lembre-se que teremos algumas chamadas na função!
1ª chamada: fatoracao(5) -> 5 * fatoracao(5-1)
2ª chamada: fatoracao(4) -> 4 * fatoracao(4-1)
3ª chamada: fatoracao(3) -> 3 * fatoracao(3-1)
4ª chamada: fatoracao(2) -> 2 * fatoracao(2-1)
5ª chamada: fatoracao(1) -> 1 * fatoracao(1-1)
​
--- Segunda parte da função recursiva
5ª chamada: return 5*(5-1)
5ª chamada: return 20*(4-1)
5ª chamada: return 60*(3-1)
5ª chamada: return 120*(2-1)
5ª chamada: return 120
*/    
}
  println(fatoracao(5))
}
//Print:
//5040

Resolução sem comentários:

fun main(){
  fun fatoracao(num: Int): Int{
  return if (num < 0){
   -1
 } else if (num == 0){ 
   1 
 } else {
   num * fatoracao(num-1)  
}
  println(fatoracao(5))
}

Usando o while

fun main() {
  println(fatoracao(5))
}
fun fatoracao(num: Int): Int {
  //criando as variávei para receber o valor de num e operar com esse valor
  var fat: Int = num
  var i: Int = num
  //retornando valores para 0 e 1
  if (num == 0 || num == 1) {
    return 1
 }
  while (i > 1) {
    i -= 1 //declaração da iteração
    fat *= i // produto de n*(n-1)
   }
  /*
     i  i -= 1  fat  fat *= i
  1ª Iteração: 5   4   5   20 = 5*4
  2ª Iteração: 4   3   20   60 = 20*3
  3ª Iteração: 3   2   60   120 = 60*2
  4ª Iteração: 2   1   120  120 = 120*1  
  Loop termina
  */
    return fat
  
}
//Print:
//5040

Resolução sem comentários:

fun main() {
  println(fatoracao(5))
}
fun fatoracao(num: Int): Int {
  var retun: Int = num
  var dec: Int = num
  if (num == 0 || num == 1) {
    return 1
 }
  while (dec > 1) {
    dec -= 1
    retun *= dec
   }
    return retun
}

Usando o for

fun main() {
​
  println(fatoracao(5))
}
fun fatoracao(num: Int): Int {
  //criando a variável para receber o valor de num 
  var fat:Int = num
  //retornando valores para 0 e 1
  if (fat == 0 || fat == 1) {
    return 1
 }
  for (i in fat - 1 downTo 1){
    fat *= i
 }
  /*
    fat   i   fat *= i
  1ª Iteração: 5   4     20 = 5*4
  2ª Iteração: 20   3     60 = 20*3
  3ª Iteração: 60   2     120 = 60*2
  4ª Iteração: 120  1     120 = 120*1     
  Loop termina
  */
  return fat
}
//Print:
//5040

Resolução sem comentários:

fun main() {
  println(fatoracao(5))
}
fun fatoracao(num: Int): Int {
  var fat:Int = num
  if (fat == 0 || fat == 1) {
    return 1
 }
  for (i in fat - 1 downTo 1){
    fat *= i
 }
  return fat
}

É isso ai pessoal, espero que esses exemplos possam ajudar vocês assim como me ajudaram. Lembrando que feedbacks construtivos são sempre bem vindos. 🤘

Abraços, até a próxima!

2
25

Comentários (2)

1
Josélio Júnior

Josélio Júnior

08/03/2021 20:50

Olá!

Tinha conseguido a fatorialização por função for de outra forma.

Caso o num seja 0 ou negativo resultam em 1, caso seja um inteiro postivo maior que 1 retornam o fatorial.

fun main() {
    println(factorial(5))
}

fun factorial(num:Int):Int{
    var f = 1
    for (i in 1..num) f *= i
    return f
}

Ótimos estudos!!! 🚀

1
Miguel Júnior

Miguel Júnior

08/03/2021 20:08

Ótimo artigo. Tenho mais um jeito de fatorizar um número :


Técnica tail recursive (recursão no final): permite escrever algoritmos recursivos eficientes que, do contrário, resultaria em erros de stack overflow (estouro de pilha).

 fun main() {
    println("5! = ${fact(5)}")
}

fun fact(k: Int): Int {
    tailrec fun factTail(m: Int, n: Int): Int {
        return if (m == 0) n
        else factTail(m - 1, m * n)
    }
    return factTail(k, 1)
}

Já trabalhei como professor de matemática, designer e já tive uma empresa de impressão 3D. Decidi migrar para essa área fantástica que a programação.

Brasil