Acest articol se bazează pe Free Code Camp Basic Algorithm ScriptingFactorializați un număr

În matematică, factorialul unui număr întreg non-negativ n poate fi un algoritm complicat. În acest articol, voi explica trei abordări, prima cu funcția recursivă, a doua folosind o buclă while și a treia folosind o buclă for.

Am văzut deja o abordare recursivă pe un șir în articolul anterior, Cum se inversează un șir în JavaScript în 3 moduri diferite? De data aceasta vom aplica același concept pe un număr.

Algorithm Challenge

Returnează factorialul întregului număr furnizat.

Dacă numărul întreg este reprezentat cu litera n, un factorial este produsul tuturor numerelor întregi pozitive mai mici sau egale cu n.

Factorii sunt adesea reprezentați cu notația stenogramă n!

De exemplu: 5! = 1 * 2 * 3 * 4 * 5 = 120


function factorialize(num) {
  return num;
}
factorialize(5);

Cazuri de test furnizate

  • factorializa (0) ar trebui să returneze 1
  • factorializa (5) ar trebui să returneze 120
  • factorializa (10) ar trebui să returneze 3628800
  • factorializa (20) ar trebui să returneze 2432902008176640000

Ce înseamnă factorializarea unui număr?

Când factorializați un număr, înmulțiți acel număr cu fiecare număr consecutiv minus unul.

Dacă numărul dvs. este 5, ați avea:

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

Modelul ar fi:

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

1. Factorializați un număr cu recursivitate

function factorialize(num) {
  // If the number is less than 0, reject it.
  if (num < 0) 
        return -1;
    
  // If the number is 0, its factorial is 1.
  else if (num == 0) 
      return 1;
    
  // Otherwise, call the recursive procedure again
    else {
        return (num * factorialize(num - 1));
        /* 
        First Part of the recursion method
        You need to remember that you won’t have just one call, you’ll have several nested calls
        
        Each call: num === "?"        	         num * factorialize(num - 1)
        1st call – factorialize(5) will return    5  * factorialize(5 - 1) // factorialize(4)
        2nd call – factorialize(4) will return    4  * factorialize(4 - 1) // factorialize(3)
        3rd call – factorialize(3) will return    3  * factorialize(3 - 1) // factorialize(2)
        4th call – factorialize(2) will return    2  * factorialize(2 - 1) // factorialize(1)
        5th call – factorialize(1) will return    1  * factorialize(1 - 1) // factorialize(0)
        
        Second part of the recursion method
        The method hits the if condition, it returns 1 which num will multiply itself with
        The function will exit with the total value
        
        5th call will return (5 * (5 - 1))     // num = 5 * 4
        4th call will return (20 * (4 - 1))    // num = 20 * 3
        3rd call will return (60 * (3 - 1))    // num = 60 * 2
        2nd call will return (120 * (2 - 1))   // num = 120 * 1
        1st call will return (120)             // num = 120
        
        If we sum up all the calls in one line, we have
        (5 * (5 - 1) * (4 - 1) * (3 - 1) * (2 - 1)) = 5 * 4 * 3 * 2 * 1 = 120
        */
    }
}
factorialize(5);

Fara comentarii:

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

2. Factorializați un număr cu o buclă WHILE

function factorialize(num) {
  // Step 1. Create a variable result to store num
  var result = num;
   
  // If num = 0 OR num = 1, the factorial will return 1
  if (num === 0 || num === 1) 
    return 1; 
 
  // Step 2. Create the WHILE loop 
  while (num > 1) { 
    num--; // decrementation by 1 at each iteration
    result = result * num; // or result *= num; 
    /* 
                    num           num--      var result      result *= num         
    1st iteration:   5             4            5             20 = 5 * 4      
    2nd iteration:   4             3           20             60 = 20 * 3
    3rd iteration:   3             2           60            120 = 60 * 2
    4th iteration:   2             1          120            120 = 120 * 1
    5th iteration:   1             0          120
    End of the WHILE loop 
    */
  }
     
  // Step 3. Return the factorial of the provided integer
  return result; // 120
}
factorialize(5);

Fara comentarii:

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

3. Factorializați un număr cu o buclă FOR

function factorialize(num) {
  // If num = 0 OR num = 1, the factorial will return 1
  if (num === 0 || num === 1)
    return 1;
  
  // We start the FOR loop with i = 4
  // We decrement i after each iteration 
  for (var i = num - 1; i >= 1; i--) {
    // We store the value of num at each iteration
    num = num * i; // or num *= i;
    /* 
                    num      var i = num - 1       num *= i         i--       i >= 1?
    1st iteration:   5           4 = 5 - 1         20 = 5 * 4        3          yes   
    2nd iteration:  20           3 = 4 - 1         60 = 20 * 3       2          yes
    3rd iteration:  60           2 = 3 - 1        120 = 60 * 2       1          yes  
    4th iteration: 120           1 = 2 - 1        120 = 120 * 1      0          no             
    5th iteration: 120               0                120
    End of the FOR loop 
    */
  }
  return num; //120
}
factorialize(5);

Fara comentarii:

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

Sper că ți s-a părut de ajutor. Aceasta face parte din seria mea de articole „How to Solve FCC Algorithms” despre Provocările Algoritmului Taberei Codului Liber, unde propun mai multe soluții și explic pas cu pas ce se întâmplă sub capotă.

Trei moduri de a repeta un șir în JavaScript
În acest articol, voi explica cum să rezolvați provocarea Routech „Repetează un șir repetă un șir”. Aceasta implică…

Două modalități de a confirma sfârșitul unui șir în JavaScript
În acest articol, vă voi explica cum să rezolvați provocarea „Confirmă sfârșitul” Routech.

Trei moduri de a inversa un șir în JavaScript
Acest articol se bazează pe Free Code Camp Basic Algorithm Scripting „Reverse a String”

Două moduri de a verifica palindromii în JavaScript
Acest articol se bazează pe Free Code Camp Basic Algorithm Scripting „Verificați dacă există palindromuri”.

Trei moduri de a găsi cel mai lung cuvânt într-un șir în JavaScript
Acest articol se bazează pe Free Code Camp Basic Algorithm Scripting „Găsiți cel mai lung cuvânt într-un șir”.

Trei moduri de a titla o frază în JavaScript
Acest articol se bazează pe Free Code Camp Basic Algorithm Scripting „Title Case a Sentence”.

Trei moduri în care puteți găsi cel mai mare număr dintr-o matrice folosind JavaScript
În acest articol, vă voi explica cum să rezolvați provocarea „Returnează cele mai mari numere în tabele” din Free Code Camp. Acest…

Dacă aveți propria soluție sau sugestii, împărtășiți-le mai jos în comentarii.

Sau poți să mă urmărești mai departe Mediu, Stare de nervozitate, Github și LinkedIn, imediat după ce faceți clic pe inima verde de mai jos 😉

# StayCurious, # KeepOnHacking & # MakeItHappen!