比使用JavaScript进行多次循环迭代更有效的解决方案

我写了一个算法，返回两个整数的最小公倍数，可以被这两个整数平分，也可以被初始两个整数之间的所有顺序整数平分

我的算法适用于最小公倍数相当低的数字。对于最小公倍数非常大的数字（例如[1,13]的360360），我的算法会中断，因为它依赖于运行越来越多的For循环

我已经在下面发布了我的代码。看起来很长，但是问题部分就在开头，其余的代码都是为上下文添加的

是否有一种更有效的解决方案可以运行越来越多的循环迭代来返回更大的数字

// If mystery failure occurs, examine i & j loop limits.
function smallestCommons(arr) {
var firstArray = [];
var secondArray = [];
var commonNums = [];
var sequential = [];

// Sort the array from lowest to highest
arr.sort(function(a,b) {
  return a-b;
});

// Assing arr values to vars so that original data stays intact
var array0 = arr[0];
var array1 = arr[1];
//console.log(arr);
// Find all multiples of both inputs.

// THIS IS THE PROBLEM SECTION
for (var i = 0; i < 1000000; i++) {
firstArray.push(arr[0] * (i+1));
}
for (var j = 0; j < 1000000; j++) {
secondArray.push(arr[1] * (j+1));
}
// THAT WAS THE PROBLEM SECTION

// Find common multiples.
for (var k = 0; k < firstArray.length; k++) {
  for (var l = 0; l < secondArray.length; l++) {
if (firstArray[k] == secondArray[l]) {
  commonNums.push(firstArray[k]);
} // End if.
} // End l loop.
} // End k loop.

// Find sequential numbers in range between input parameters.
for (var m = 0; m < array1; m++) {
if (array0 + 1 !== array1) {
  sequential.push(array0 += 1);
} // End of if.
} // End of m loop.

// Find commonNums divisible by arr && sequential to produce a whole number.
// commonNums [ 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75]
// arr [1,5]
// sequential [ 2, 3, 4 ]
for (var n = 0; n < commonNums.length; n++) {
    var match = true;
    for (var o = 0; o < sequential.length; o++) {
        for (var p = 0; p < arr.length; p++) {
            if (commonNums[n] % arr[p] !== 0 || commonNums[n] % sequential[o] !== 0) {
                match = false;
            }
        }
    }
    if(match) {
console.log(commonNums[n]);
    }

} // End of n loop.

} // End function.

smallestCommons([1,13]);

//如果出现神秘故障，检查i&j回路限制。
功能最小公共空间（arr）{
var firstArray=[]；
var secondArray=[]；
var commonNums=[]；
var序列=[]；
//将数组从最低到最高排序
arr.sort（函数（a，b）{
返回a-b；
});
//将arr值分配给VAR，以便原始数据保持完整
var array0=arr[0]；
var array1=arr[1]；
//控制台日志（arr）；
//查找两个输入的所有倍数。
//这是问题部分
对于（变量i=0；i<1000000；i++）{
push（arr[0]*（i+1））；
}
对于（var j=0；j<1000000；j++）{
push（arr[1]*（j+1））；
}
//这就是问题所在
//找到公共倍数。
for（var k=0；k

听起来是个好地方，因为当数字差为1时（在您的示例中，

smallestCommons（[12,13]）；

或

smallestCommons（[1,2]）；

取决于方向）和其他（顺序）都有坚实的基础在递归调用中，将递增较小的数或递减较大的数。这可以为您节省不少CPU周期。

您所做的事情没有多大意义，而且很难阅读。要解决这个问题，你只需要知道一点数学知识。这个数学告诉你：

lcm(a, b) = a * b / gcd(a, b)
lcm(a,b,c) = lcm(a,lcm(b,c))

也就是说：

function gcd(a, b){
  while (b !== 0) {
    var tmp = a;
    a = b;
    b = tmp % b;
  }
  return a
}

function lcm(a, b){
  return a * b / gcd(a, b);
}

function lcm_arr(arr){
  var res = 1;
  for (var i = 0; i < arr.length; i++){
     res = lcm(res, arr[i]);
  }
  return res;
}

功能gcd（a、b）{
而（b！==0）{
var tmp=a；
a=b；
b=tmp%b；
}
归还
}
功能lcm（a、b）{
返回a*b/gcd（a，b）；
}
功能lcm_arr（arr）{
var-res=1；
对于（变量i=0；i

这将在不到一秒钟的时间内为您提供结果：

---

<代码> LCMYARR（[1, 2, 3，4, 5, 6，7, 8, 9，10, 11, 12，13）] < /C>>/P> ES6应该已经设置，也可以删除循环二次数组，也许你可以考虑把这个问题移到，因为它本身没有错误或问题，但是需要优化。在无限长的语言中，你要做的是<代码> LCM（LCM）。（上半部分）、lcm（下半部分））。这将表现得更好。