Artigo original: Three Ways to Factorialize a Number in JavaScript

Este artigo tem como base o desafio de criação de algoritmos básicos "Encontrar o fatorial de um número" do freeCodeCamp

Em matemática, o fatorial de um número inteiro n não negativo pode produzir um algoritmo complicado. Neste artigo, explicarei três abordagens: a primeira com uma função recursiva, a segunda com um laço while e a terceira com um laço for.

Já vimos a abordagem de recursão em uma string em um artigo anterior, "Três maneiras de inverter uma string em JavaScript". Desta vez, aplicaremos o mesmo conceito, mas a um número.

Desafio do algoritmo

Retorne o fatorial do inteiro fornecido.

Se o inteiro é representado com a letra n, o fatorial é o produto de todos os inteiros positivos menores ou iguais a n.

Fatoriais são frequentemente representados com a notação abreviada n!

Por exemplo: 5! = 1 * 2 * 3 * 4 * 5 = 120
function factorialize(num) {
  return num;
}
factorialize(5);

Casos de teste fornecidos

  • factorialize(0) deve retornar 1
  • factorialize(5) deve retornar 120
  • factorialize(10) deve retornar 3628800
  • factorialize(20) deve retornar 2432902008176640000

O que é encontrar o fatorial de um número?

Para encontrar o fatorial de um número, multiplicamos aquele número por cada número consecutivo menos um.

Se o seu número for 5, teremos:

5! = 5 * 4 * 3 * 2 * 1

O padrão seria algo como:

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

1. Encontrar o fatorial de um número com recursão

function factorialize(num) {
  // Se o número for inferior a 0, rejeite-o.
  if (num < 0) 
        return -1;
    
  // Se o número for 0, seu fatorial é 1.
  else if (num == 0) 
      return 1;
    
  // Caso contrário, chame o procedimento de recursão novamente
    else {
        return (num * factorialize(num - 1));
        /* 
        Primeira parte do método de recursão
        É preciso lembrar que você não terá apenas uma chamada, mas diversas chamadas "aninhadas"
        
        Cada chamada: num === "?"      	         num * factorialize(num - 1)
        1ª chamada – factorialize(5) retornará    5  * factorialize(5 - 1) // factorialize(4)
        2ª chamada – factorialize(4) retornará    4  * factorialize(4 - 1) // factorialize(3)
        3ª chamada – factorialize(3) retornará    3  * factorialize(3 - 1) // factorialize(2)
        4ª chamada – factorialize(2) retornará    2  * factorialize(2 - 1) // factorialize(1)
        5ª chamada – factorialize(1) retornará    1  * factorialize(1 - 1) // factorialize(0)
        
        Segunda parte do método de recursão
        O método chega na condição do if, retorna 1, com o qual num será multiplicado
        A função sairá retornando o valor total
        
        A 5ª chamada retornará (5 * (5 - 1))     // num = 5 * 4
        A 4ª chamada retornará (20 * (4 - 1))    // num = 20 * 3
        A 3ª chamada retornará (60 * (3 - 1))    // num = 60 * 2
        A 2ª chamada retornará (120 * (2 - 1))   // num = 120 * 1
        A 1ª chamada retornará (120)             // num = 120
        
        Se somarmos todas as chamadas em uma linha, temos
        (5 * (5 - 1) * (4 - 1) * (3 - 1) * (2 - 1)) = 5 * 4 * 3 * 2 * 1 = 120
        */
    }
}
factorialize(5);

Sem os comentários:

function factorialize(num) {
  if (num < 0) 
        return -1;
  else if (num == 0) 
      return 1;
  else {
      return (num * factorialize(num - 1));
  }
}
factorialize(5);

2. Encontrar o fatorial de um número com um laço WHILE

function factorialize(num) {
  // Passo 1. Criar uma variável result para armazenar o valor de num
  var result = num;
   
  // Se num = 0 OU num = 1, o fatorial retornará 1
  if (num === 0 || num === 1) 
    return 1; 
 
  // Passo 2. Criar o laço WHILE 
  while (num > 1) { 
    num--; // diminuir 1 a cada iteração
    result = result * num; // ou result *= num; 
    /* 
                    num           num--      var result      result *= num         
    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
    5ª iteração:   1             0          120
    Fim do laço WHILE 
    */
  }
     
  // Passo 3. Retornar o fatorial do inteiro fornecido
  return result; // 120
}
factorialize(5);

Sem os comentários:

function factorialize(num) {
  var result = num;
  if (num === 0 || num === 1) 
    return 1; 
  while (num > 1) { 
    num--;
    result *= num;
  }
  return result;
}
factorialize(5);

3. Encontrar o fatorial de um número com um laço FOR

function factorialize(num) {
  // Se num = 0 OU num = 1, o fatorial retornará 1
  if (num === 0 || num === 1)
    return 1;
  
  // Começamos o laço FOR loop com i = 5
  // Diminuímos i em uma unidade após cada iteração 
  for (var i = num - 1; i >= 1; i--) {
    // Armazenamos o valor de num a cada iteração
    num = num * i; // ou num *= i;
    /* 
                 num    var i = num - 1   num *= i         i--       i >= 1?
    1ª iteração:   5    4 = 5 - 1         20 = 5 * 4        3          sim   
    2ª iteração:  20    3 = 4 - 1         60 = 20 * 3       2          sim
    3ª iteração:  60    2 = 3 - 1        120 = 60 * 2       1          sim  
    4ª iteração: 120    1 = 2 - 1        120 = 120 * 1      0          não 
    5ª iteração: 120    0                120
    Fim do laço FOR 
    */
  }
  return num; //120
}
factorialize(5);

Sem os comentários:

function factorialize(num) {
  if (num === 0 || num === 1)
    return 1;
  for (var i = num - 1; i >= 1; i--) {
    num *= i;
  }
  return num;
}
factorialize(5);

Espero que você tenha achado este artigo útil. Ele é parte da minha série de artigos "Como solucionar os algoritmos do fCC" sobre os desafios de algoritmos do Free Code Camp, onde eu proponho diversas soluções e explico o passo a passo do que acontece nos algoritmos internamente.

Três maneiras de repetir uma string em JavaScript (texto em inglês)
Neste artigo, eu explico como resolver o desafio "Repetir uma string Repetir uma string" do freeCodeCamp.

Duas maneiras de se confirmar o fim de uma string em JavaScript (texto em inglês)
Neste artigo, eu explico como resolver o desafio "Confirmar o final" do freeCodeCamp.

Três maneiras de inverter uma string em JavaScript
Este artigo tem como base o desafio de scripts de algoritmos básicos "Inverter uma string" do freeCodeCamp.

Duas maneiras de verificar palíndromos em JavaScript (texto em inglês)
Este artigo tem como base o desafio "Verificador de palíndromo" do freeCodeCamp.

Três maneiras de encontrar a palavra mais longa em uma string em JavaScript (texto em inglês)
Este artigo tem como base o desafio de scripts de algoritmos básicos "Encontrar a palavra mais longa em uma string" do freeCodeCamp.

Três maneiras de capitalizar a primeira letra de cada palavra de uma frase em JavaScript (texto em inglês)
Este artigo tem como base o desafio de scripts de algoritmos básicos "Capitalizar a primeira letra de cada palavra de uma frase" do freeCodeCamp.

Três maneiras de encontrar o maior número em um array usando JavaScript (texto em inglês)
Neste artigo, eu explico como resolver o desafio "Retornar os maiores números em arrays" do freeCodeCamp.

Se você tiver sua própria solução ou se tiver sugestões, compartilhe-as.

Você também pode seguir a autora no Medium, no Twitter, no Github e no LinkedIn ;-)

‪#‎SigaCurioso‬, ‪#SigaProgramando e ‪#‎FaçaAcontecer!