Tres forms de factorizar un numero en JavaScript

Artículo original escrito bởi: Sonya Moisset
Nghệ thuật gốc: Ba cách để thừa số hóa một số trong JavaScript
Traducido và Adaptado por: Sil Zubikarai

Bài viết này dựa trên chương trình freeCodeCamp của Thuật toán Básicos “Factoriza un numberero”.

En matematicas, giai thừa của một nhập không phủ định có thể là một thuật toán phức tạp. Trong bài viết này, hãy giải thích một số vấn đề, bước đầu với chức năng đệ quy, sau đó sử dụng khóa trong khi y tercero sử dụng khóa cho.

Bạn đang xem cách truy cập đệ quy vào dòng văn bản trong bài viết trước, bạn có muốn đảo ngược một dòng JavaScript trong ba định dạng khác nhau không? Esta vez vamos aplicar el mismo concepto en un numberero.

Giải quyết thuật toán

Devuelve el giai thừa del entero proporcionado.

Si el entero es được đại diện bởi letra n, el producto factorial de todos los enteros positivos menores o iguales a n.

Giai thừa chính quy con trai đại diện cho abreviatura N!

Ví dụ: 5! = 1 * 2 * 3 * 4 * 5 = 120

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

Casos de prueba proporcionados

• giai thừa hóa (0) Debe hồi quy 1
• giai thừa hóa(5) Debe hồi quy 120
• giai thừa hóa(10) Debe hồi quy 3628800
• giai thừa hóa(20) Debe hồi quy 2432902008176640000

¿De qué se trata factorizar un numberero?

Khi bạn thừa số một số, bạn có thể nhân số này bằng số khác vì số lần sau đó là một.

Si tu number es 5, deberías tener:

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

Người bảo trợ được yêu cầu:

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

1. Thừa số không cho đệ quy

function factorialize(num) {
  // Si el número es menor que 0, rechacelo. 
  if (num < 0) 
        return -1;
    
  // Si el número es 0, su factorial es 1.
  else if (num == 0) 
      return 1;
    
  // De otra forma, llama al procedimiento de nuevo
    else {
        return (num * factorialize(num - 1));
        /* 
   Primera parte del metodo recursion
        Necesitas recordar que no solo tendras solo una llamada, tendras varias llamadas anidadas.
        
        cada llamada: num === "?"        	         num * factorialize(num - 1)
        1ª llamada – factorialize(5) devolvera    5  * factorialize(5 - 1) // factorialize(4)
        2ª llamada – factorialize(4) devolvera    4  * factorialize(4 - 1) // factorialize(3)
        3ª llamada – factorialize(3) devolvera    3  * factorialize(3 - 1) // factorialize(2)
        4ª llamada – factorialize(2) devolvera    2  * factorialize(2 - 1) // factorialize(1)
        5ª llamada – factorialize(1) devolvera    1  * factorialize(1 - 1) // factorialize(0)
        
         Segunda parte del metodo recursion
     Si el metodo toca la condicion if, y regresa 1 cuando el numero se multiplica asi mismo.
         La funcion regresara con el valor total
        
        5ª la llamada devolvera (5 * (5 - 1))     // num = 5 * 4
        4ª la llamada devolvera (20 * (4 - 1))    // num = 20 * 3
        3ª la llamada devolvera (60 * (3 - 1))    // num = 60 * 2
        2ª la llamada devolvera (120 * (2 - 1))   // num = 120 * 1
        1ª la llamada devolvera (120)             // num = 120
        
        Si sumamonos todas las llamadas en una linea, tenemos
        (5 * (5 - 1) * (4 - 1) * (3 - 1) * (2 - 1)) = 5 * 4 * 3 * 2 * 1 = 120
        */
    }
}
factorialize(5);

Bình luận tội lỗi:

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

2. Yếu tố không đánh số với khóa WHILE

function factorialize(num) {
  // Paso 1. Crea una variable resultado que guarda num
  var result = num;
   
  // Si num = 0 O num = 1, el factorial devolverá 1
  if (num === 0 || num === 1) 
    return 1; 
 
  // Paso 2. Crea un bucle WHILE
  while (num > 1) { 
    num--; // decrementation by 1 at each iteration
    result = result * num; // or result *= num; 
    /* 
                    num           num--      var result      result *= num         
    1ª iteración:   5             4            5             20 = 5 * 4      
    2ª iteración:   4             3           20             60 = 20 * 3
    3ª iteración:   3             2           60            120 = 60 * 2
    4ª iteración:   2             1          120            120 = 120 * 1
    5ª iteración:   1             0          120
    Fin del bucle WHILE
    */
  }
     
  // Paso 3. Regresa el factorialdel integral dado
  return result; // 120
}
factorialize(5);

Bình luận tội lỗi:

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

3. Hệ số un number con el bucle FOR

function factorialize(num) {
  // Si num = 0 OR num = 1, el factorial regresa 1
  if (num === 0 || num === 1)
    return 1;
  
  // Empezamos el bucle FOR con i = 4
  //Decremento i después de cada iteración
  for (var i = num - 1; i >= 1; i--) {
    //Guardamos el valor de num en cada iteración
    num = num * i; // o num *= i;
    /* 
                    num      var i = num - 1       num *= i         i--       i >= 1?
    1ª iteración:   5           4 = 5 - 1         20 = 5 * 4        3          yes   
    2ª iteración:  20           3 = 4 - 1         60 = 20 * 3       2          yes
    3ª iteración:  60           2 = 3 - 1        120 = 60 * 2       1          yes  
    4ª iteración: 120           1 = 2 - 1        120 = 120 * 1      0          no             
    5ª iteración: 120               0                120
    Fin del bucle FOR 
    */
  }
  return num; //120
}
factorialize(5);

Bình luận tội lỗi:

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 hayas encontrado estoutil.

Puedes seguirme en Trung bình, Twitter, Github, y LinkedIn