Hướng dẫn what is least common multiple javascript? - javascript nhiều phổ biến nhất là gì?

Question

Cập nhật lần cuối vào ngày 19 tháng 8 năm 2022 21:50:50 (UTC/GMT +8 giờ)

Toán JavaScript: Bài tập-10 với giải pháp

Viết hàm JavaScript để có được bội số (LCM) ít nhất của hai số. Các bội số phổ biến của 3 và 4 là 0, 12, 24, .... bội số (LCM) ít nhất của hai số là số nhỏ nhất (không phải bằng 0) là bội số của cả hai.
Note :
According to Wikipedia - A common multiple is a number that is a multiple of two or more integers. The common multiples of 3 and 4 are 0, 12, 24, .... The least common multiple (LCM) of two numbers is the smallest number (not zero) that is a multiple of both.

Nội dung chính Show

Toán JavaScript: Bài tập-10 với giải pháp
JavaScript: Lời khuyên trong ngày
Làm thế nào để bạn tìm thấy bội số ít phổ biến nhất trong JavaScript?
Đa bội số ít phổ biến nhất là gì?
Nhiều người ít phổ biến nhất và ví dụ là gì?

Dữ liệu kiểm tra: Console.log (LCM_TWO_NUMBERS (3,15)); Console.log (LCM_TWO_NUMBERS (10,15)); Đầu ra: 15 30
console.log(lcm_two_numbers(3,15));
console.log(lcm_two_numbers(10,15));
Output :
15
30

Giải thích về L.C.M .:

Trình bày bằng hình ảnh của L.C.M. của hai số:

Hướng dẫn what is least common multiple javascript? - javascript nhiều phổ biến nhất là gì?

Giải pháp mẫu:-

Mã HTML:


  
  
  
  LCM of two numbers

Mã JavaScript:

function lcm_two_numbers(x, y) {
   if ((typeof x !== 'number') || (typeof y !== 'number')) 
    return false;
  return (!x || !y) ? 0 : Math.abs((x * y) / gcd_two_numbers(x, y));
}

function gcd_two_numbers(x, y) {
  x = Math.abs(x);
  y = Math.abs(y);
  while(y) {
    var t = y;
    y = x % y;
    x = t;
  }
  return x;
}
console.log(lcm_two_numbers(3,15));
console.log(lcm_two_numbers(10,15));

Đầu ra mẫu:

15
30

Sơ đồ:

Bản thử trực tiếp:

Xem bút JavaScript-Math-Escise-10 của W3Resource (@W3Resource) trên CodePen.

Cải thiện giải pháp mẫu này và đăng mã của bạn thông qua Disqus

Trước đây: Viết hàm JavaScript để tìm GCD (ước số chung lớn nhất) của hơn 2 số nguyên. Write a JavaScript function to find the GCD (greatest common divisor) of more than 2 integers.
Next: Write a JavaScript function to get the least common multiple (LCM) of more than 2 integers.

JavaScript: Lời khuyên trong ngày

Giá trị của tham số

function getItems(fruitList, ...args, favoriteFruit) {
  return [...fruitList, ...args, favoriteFruit]
}

getItems(["banana", "apple"], "pear", "orange")

... Args là một tham số nghỉ ngơi. Giá trị của tham số REST là một mảng chứa tất cả các đối số còn lại và chỉ có thể là tham số cuối cùng! Trong ví dụ này, tham số REST là tham số thứ hai. Điều này là không thể, và sẽ ném lỗi cú pháp.

function getItems(fruitList, favoriteFruit, ...args) {
  return [...fruitList, ...args, favoriteFruit];
}


getItems(['banana', 'apple'], 'pear', 'orange');

Ví dụ trên hoạt động. Điều này trả về mảng ['chuối', 'Apple', 'Orange', 'Pear'].

Tham khảo: https://bit.ly/3jfrbje

Ban đầu, bạn có thể đã có một luồng tràn chồng vì một lỗi đánh máy: bạn đã chuyển đổi giữa min và

function lcm_two_numbers(x, y) {
   if ((typeof x !== 'number') || (typeof y !== 'number')) 
    return false;
  return (!x || !y) ? 0 : Math.abs((x * y) / gcd_two_numbers(x, y));
}

function gcd_two_numbers(x, y) {
  x = Math.abs(x);
  y = Math.abs(y);
  while(y) {
    var t = y;
    y = x % y;
    x = t;
  }
  return x;
}
console.log(lcm_two_numbers(3,15));
console.log(lcm_two_numbers(10,15));

0 ở giữa

function lcm_two_numbers(x, y) {
   if ((typeof x !== 'number') || (typeof y !== 'number')) 
    return false;
  return (!x || !y) ? 0 : Math.abs((x * y) / gcd_two_numbers(x, y));
}

function gcd_two_numbers(x, y) {
  x = Math.abs(x);
  y = Math.abs(y);
  while(y) {
    var t = y;
    y = x % y;
    x = t;
  }
  return x;
}
console.log(lcm_two_numbers(3,15));
console.log(lcm_two_numbers(10,15));

1 (bạn sẽ bắt gặp rằng nếu

function lcm_two_numbers(x, y) {
   if ((typeof x !== 'number') || (typeof y !== 'number')) 
    return false;
  return (!x || !y) ? 0 : Math.abs((x * y) / gcd_two_numbers(x, y));
}

function gcd_two_numbers(x, y) {
  x = Math.abs(x);
  y = Math.abs(y);
  while(y) {
    var t = y;
    y = x % y;
    x = t;
  }
  return x;
}
console.log(lcm_two_numbers(3,15));
console.log(lcm_two_numbers(10,15));

1 đã được xác định ở hàm bên ngoài). Với đó cố định,

function lcm_two_numbers(x, y) {
   if ((typeof x !== 'number') || (typeof y !== 'number')) 
    return false;
  return (!x || !y) ? 0 : Math.abs((x * y) / gcd_two_numbers(x, y));
}

function gcd_two_numbers(x, y) {
  x = Math.abs(x);
  y = Math.abs(y);
  while(y) {
    var t = y;
    y = x % y;
    x = t;
  }
  return x;
}
console.log(lcm_two_numbers(3,15));
console.log(lcm_two_numbers(10,15));

3 trả về 156.

Câu trả lời rõ ràng để tránh tràn ngăn xếp là biến hàm đệ quy thành một hàm không nhận được. Bạn có thể thực hiện điều đó bằng cách làm:

function repeatRecurse(min, max, scm) {
    while ( min < max ) {
        while ( scm % min !== 0 ) {
            scm += max;
        }
        min++;
    }
}

Nhưng có lẽ bạn có thể thấy sai lầm vào thời điểm này: Bạn không đảm bảo rằng

function lcm_two_numbers(x, y) {
   if ((typeof x !== 'number') || (typeof y !== 'number')) 
    return false;
  return (!x || !y) ? 0 : Math.abs((x * y) / gcd_two_numbers(x, y));
}

function gcd_two_numbers(x, y) {
  x = Math.abs(x);
  y = Math.abs(y);
  while(y) {
    var t = y;
    y = x % y;
    x = t;
  }
  return x;
}
console.log(lcm_two_numbers(3,15));
console.log(lcm_two_numbers(10,15));

4 vẫn chia hết bởi các yếu tố xuất hiện trước min. Ví dụ,

function lcm_two_numbers(x, y) {
   if ((typeof x !== 'number') || (typeof y !== 'number')) 
    return false;
  return (!x || !y) ? 0 : Math.abs((x * y) / gcd_two_numbers(x, y));
}

function gcd_two_numbers(x, y) {
  x = Math.abs(x);
  y = Math.abs(y);
  while(y) {
    var t = y;
    y = x % y;
    x = t;
  }
  return x;
}
console.log(lcm_two_numbers(3,15));
console.log(lcm_two_numbers(10,15));

6. Thay vì thêm

function lcm_two_numbers(x, y) {
   if ((typeof x !== 'number') || (typeof y !== 'number')) 
    return false;
  return (!x || !y) ? 0 : Math.abs((x * y) / gcd_two_numbers(x, y));
}

function gcd_two_numbers(x, y) {
  x = Math.abs(x);
  y = Math.abs(y);
  while(y) {
    var t = y;
    y = x % y;
    x = t;
  }
  return x;
}
console.log(lcm_two_numbers(3,15));
console.log(lcm_two_numbers(10,15));

7, bạn muốn thay thế

function lcm_two_numbers(x, y) {
   if ((typeof x !== 'number') || (typeof y !== 'number')) 
    return false;
  return (!x || !y) ? 0 : Math.abs((x * y) / gcd_two_numbers(x, y));
}

function gcd_two_numbers(x, y) {
  x = Math.abs(x);
  y = Math.abs(y);
  while(y) {
    var t = y;
    y = x % y;
    x = t;
  }
  return x;
}
console.log(lcm_two_numbers(3,15));
console.log(lcm_two_numbers(10,15));

4 bằng bội số ít nhất với min. Bạn có thể sử dụng RGBCHRIS từ GCD (đối với số nguyên,

15
30

0 là điều tương tự như

15
30

1). Nếu bạn muốn giữ cho tối ưu hóa đuôi (mặc dù tôi không nghĩ rằng bất kỳ động cơ JavaScript nào cũng có tối ưu hóa đuôi), bạn sẽ kết thúc với:

function repeatRecurse(min, max, scm) {
    if ( min < max ) {
        return repeatRecurse(min+1, max, lcm(scm,min));
    }
    return scm;
}

Hoặc không có đệ quy:

function repeatRecurse(min,max,scm) {
    while ( min < max ) {
        scm = lcm(scm,min);
        min++;
    }
    return scm;
}

Điều này về cơ bản tương đương với giải pháp RGBCHRIS. Một phương pháp thanh lịch hơn có thể là phân chia và chinh phục:

function repeatRecurse(min,max) {
    if ( min === max ) {
        return min;
    }
    var middle = Math.floor((min+max)/2);
    return lcm(repeatRecurse(min,middle),repeatRecurse(middle+1,max));
}

Tôi sẽ khuyên bạn nên di chuyển khỏi đối số ban đầu là một mảng gồm hai số. Đối với một điều, nó kết thúc khiến bạn nói về hai mảng khác nhau:

15
30

2 và mảng phạm vi. Đối với một điều khác, sẽ rất dễ dàng để vượt qua một mảng dài hơn và không bao giờ nhận ra bạn đã làm điều gì đó sai. Nó cũng yêu cầu một số dòng mã để xác định tối thiểu và tối đa, khi những người nên được xác định bởi người gọi.

Cuối cùng, nếu bạn sẽ làm việc với số lượng thực sự lớn, có thể tốt hơn là tìm thấy nhiều người ít phổ biến nhất bằng cách sử dụng yếu tố chính của các số.

Làm thế nào để bạn tìm thấy bội số ít phổ biến nhất trong JavaScript?

Chúng tôi sẽ sử dụng điều này để tìm kết quả ...

Đặt lcm = (n1, n2) => {// tìm gcd đầu tiên đặt gcd = gcd (n1, n2);// sau đó tính toán lợi nhuận LCM (n1 * n2) /gcd;} Sao chép ..

log (LCM (15, 20));Bảng điều khiển.....

Đặt lcm = (n1, n2) => {// Tìm số nhỏ nhất và lớn nhất từ cả hai số cho lar = math.....

Đầu vào: Bảng điều khiển ..

Đa bội số ít phổ biến nhất là gì?

LCM là gì?LCM đứng cho nhiều người ít phổ biến nhất.Bội số ít phổ biến nhất của hai số là số nhỏ nhất là bội số của cả hai.the smallest number that is a multiple of both of them.

Nhiều người ít phổ biến nhất và ví dụ là gì?

LCM biểu thị yếu tố phổ biến nhất hoặc bội số của bất kỳ hai hoặc nhiều số nguyên được đưa ra.Ví dụ, L.C.M là 16 và 20 sẽ là 2 x 2 x 2 x 2 x 5 = 80, trong đó 80 là bội số phổ biến nhỏ nhất cho các số 16 và 20.denotes the least common factor or multiple of any two or more given integers. For example, L.C.M of 16 and 20 will be 2 x 2 x 2 x 2 x 5 = 80, where 80 is the smallest common multiple for numbers 16 and 20.

programming javascript Euclidean distance JavaScript LCM recursion JavaScript algorithms JavaScript example JavaScript algorithm examples

Hướng dẫn what is least common multiple javascript? - javascript nhiều phổ biến nhất là gì?

Toán JavaScript: Bài tập-10 với giải pháp

JavaScript: Lời khuyên trong ngày

Làm thế nào để bạn tìm thấy bội số ít phổ biến nhất trong JavaScript?

Đa bội số ít phổ biến nhất là gì?

Nhiều người ít phổ biến nhất và ví dụ là gì?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội