Javascript 如何找到一系列数字的最小公倍数？

给定一个由两个数字组成的数组，让它们定义一系列数字的起点和终点。例如，

[2,6]

表示范围2,3,4,5,6。我想编写javascript代码来查找该范围内最不常见的倍数。下面的代码仅适用于小范围，而不是类似于导致堆栈溢出的

[1,13]

（范围1,2,3,4,5,6,7,8,9,10,11,12,13）。如何有效地找到范围的最小公倍数

function leastCommonMultiple(arr) {
    var minn, max;
    if ( arr[0] > arr[1] ) {
        minn = arr[1];
        max = arr[0];
    } else {
        minn = arr[0];
        max = arr[1];
    }
    function repeatRecurse(min, max, scm) {
        if ( scm % min === 0 && min < max ) {
            return repeatRecurse(min+1, max, scm);
        } else if ( scm % min !== 0 && min < max ) {
            return repeatRecurse(minn, max, scm+max);
        }
        return scm;
    } 
    return repeatRecurse(minn, max, max);
}

函数leastCommonMultiple（arr）{
var minn，max；
if（arr[0]>arr[1]）{
minn=arr[1]；
max=arr[0]；
}否则{
minn=arr[0]；
max=arr[1]；
}
函数repeatRecurse（最小、最大、scm）{
如果（scm%min==0&&min

我认为这就完成了任务

function leastCommonMultiple(min, max) {
    function range(min, max) {
        var arr = [];
        for (var i = min; i <= max; i++) {
            arr.push(i);
        }
        return arr;
    }

    function gcd(a, b) {
        return !b ? a : gcd(b, a % b);
    }

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

    var multiple = min;
    range(min, max).forEach(function(n) {
        multiple = lcm(multiple, n);
    });

    return multiple;
}

leastCommonMultiple(1, 13); // => 360360

函数最小公倍数（最小、最大）{
功能范围（最小、最大）{
var-arr=[]；
对于（var i=min；i 360360

功能最小公共多重（arr）{
/*
功能范围（最小、最大）{
var-arr=[]；
对于（var i=min；i arr[1]）{
min=arr[1]；
}
否则{
最小值=arr[0]
}
功能gcd（a、b）{
返回！b？a:gcd（b，a%b）；
}
功能lcm（a、b）{
报税表（a*b）/gcd（a、b）；
}
var倍数=最小值；
范围.forEach（函数（n）{
倍数=lcm（倍数，n）；
});
返回倍数；
}

---

console.log（leastCommonMultiple（[1,13]）

在解决方案中发挥得很好。我想我得到的一个可能会短一些，仅供将来参考，但我会仔细研究你的

function LCM(arrayRange) {
    var newArr = [];

    for (var j = arrayRange[0]; j <= arrayRange[1]; j++){
        newArr.push(j);
    }

    var a = Math.abs(newArr[0]);
    for (var i = 1; i < newArr.length; i++) {
        var b = Math.abs(newArr[i]),
            c = a;

        while (a && b) {
            a > b ? a %= b : b %= a;
        }
        a = Math.abs(c * newArr[i] / (a + b))
    }
   return console.log(a);
}

LCM([1,5]);

功能LCM（arrayRange）{
var newArr=[]；
对于（var j=arrayRange[0]；j b？a%=b:b%=a；
}
a=数学abs（c*newArr[i]/（a+b））
}
返回控制台日志（a）；
}
LCM（[1,5]）；
<或代码> 您可能因为一个打印错误而有一个堆栈溢出：您在代码< min >代码>和<代码> min n >代码>中间的<代码>重复递归< /代码>（如果在外部函数中没有定义“代码>重复递归< /代码>”），用固定的，<代码>重复递归（1，13，13）。

返回156

避免堆栈溢出的明显方法是将递归函数转换为非递归函数。您可以通过执行以下操作来实现：

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

或者不使用递归：

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

我建议不要使用由两个数字组成的数组作为原始参数。首先，它会导致您讨论两个不同的数组：

[min，max]

和范围数组。另一方面，通过更长的数组很容易，而且永远不会意识到自己做错了什么。它还需要几行代码来确定最小值和最大值，而这些值本应由调用者确定

---

最后，如果要处理真正的大数，最好使用数的素数分解找到最小公倍数。

这是原始方法的非递归版本

function smallestCommons（arr）{
//对数组进行排序
arr=arr.sort（函数（a，b）{返回a-b}）；//数值比较；
var min=arr[0]；
var max=arr[1]；
var数=[]；
var计数=0；
//这里将值的范围推送到一个数组中
对于（var i=min；i
功能范围（min，max）{
var-arr=[]；
对于[a，b]范围内的（var i=min；iLCM函数）
//大公约数的欧几里德算法
功能gcd（a、b）
{ 
返回！b？a:gcd（b，a%b）；
} 
//最小公倍数函数
功能lcm（a、b）
{
返回a*（b/gcd（a，b））；
}
//arr范围内所有数字的LCM=[a，b]
功能范围\u lcm（arr）
{
//交换[大，小]到[小，大]
如果（arr[0]>arr[1]）（arr=[arr[1]，arr[0]]）；
对于（x=result=arr[0]；x


//最大公分母的欧几里德算法
功能gcd（a、b）{
返回！b？a:gcd（b，a%b）；
}
//最小公倍数的欧几里德算法
功能lcm（a、b）{
返回a*（b/gcd（a，b））；
}
//arr范围内所有数字的LCM=[a，b]；
功能最小公共空间（arr）{
var i，结果；
//大到小-小到大
if（arr[0]>arr[1]）{
反向排列（）；
}//只发生一次。表示arr的顺序颠倒。
对于（i=result=arr[0]；i
函数lcm（arr）{
var max=Math.max（arr[0]，arr[1]），
最小值=数学最小值（arr[0]，arr[1]），
lcm=最大值；
var calcLcm=函数（a，b）{
var-mult=1；
对于（变量j=1；j=min；i--）{
lcm=calcLcm（i，lcm）；
}
返回lcm；
}
lcm（[1,13]）；//应该返回360360。

用于计算序列号的函数
在arg值之间的范围内，两者都包括在内*/
函数smallestCommons（arg1、arg2）{
如果（arg1>arg2）{//如果arg1大于arg2，则交换arg1和arg2
var-temp=arg1；
arg1=arg2；
arg2=温度；
}
/*
计算最大公约数（gcd）的辅助函数
欧几里德算法的实现*/
功能gcd（a、b）{
返回b==0？a:gcd（b，a%b）；
}
/*
用于计算最低公倍数（lcm）的辅助函数
使用上述gcd函数的任意两个数字的*/
功能lcm（a、b）{
报税表（a*b）/gcd（a、b）；
}
var total=arg1；//复制最小值
对于（var i=arg1；i
函数smallestCommons（arr）{
var max=数学最大值（…arr）；
var min=数学最小值（…arr）；
var候选者=最大值；
var smallestCommon=功能（低、高）{
//使用“高”变量的内部函数
函数scm（l，h）{
如果（h%l==0）{
R
function repeatRecurse(min, max, scm) {
    if ( min < max ) {
        return repeatRecurse(min+1, max, lcm(scm,min));
    }
    return scm;
} 

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

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));
}

function range(min, max) {
  var arr = [];
  for (var i = min; i <= max; i++) {
    arr.push(i);
  }
  return arr;
}

function gcd (x, y) {
  return (x % y === 0) ? y : gcd(y, x%y);
}

function lcm (x, y) {
  return (x * y) / gcd(x, y); 
}

function lcmForArr (min, max) {
  var arr = range(min, max);
  return arr.reduce(function(x, y) {
    return lcm(x, y); 
  });
}

range(10, 15); // [10, 11, 12, 13, 14, 15]
gcd(10, 15); // 5
lcm(10, 15); // 30
lcmForArr(10, 15); //60060

function lcm(arr) {
  var max = Math.max(arr[0],arr[1]),
      min = Math.min(arr[0],arr[1]),
      lcm = max;
  var calcLcm = function(a,b){
    var mult=1;
    for(var j=1; j<=a; j++){
      mult=b*j;
      if(mult%a === 0){
        return mult;
      }
    }
  };
  for(var i=max-1;i>=min;i--){
    lcm=calcLcm(i,lcm);
  }
  return lcm;
}
lcm([1,13]); //should return 360360.



    /*Function to calculate sequential numbers 
in the range between the arg values, both inclusive.*/
    function smallestCommons(arg1, arg2) {
     
       if(arg1>arg2) { // Swap arg1 and arg2 if arg1 is greater than arg2
          var temp = arg1;
          arg1 = arg2;
          arg2 =temp;
        }
      
      /*
      Helper function to calculate greatest common divisor (gcd)
      implementing Euclidean algorithm */
      function gcd(a, b) {
      	return b===0 ? a : gcd(b, a % b); 
       }
      
      /*
      Helper function to calculate lowest common multiple (lcm) 
of any two numbers using gcd function above */
       function lcm(a,b){
          return (a*b)/gcd(a,b);
         }
      
      var total = arg1; // copy min value
      for(var i=arg1;i<arg2;i++){
          total = lcm(total,i+1);
         }
      //return that total
      return total;
    }
    /*Yes, there are many solutions that can get the job done.
    Check this out, same approach but different view point.
    */
    console.log(smallestCommons(13,1)); //360360
function smallestCommons(arr) {
  var max = Math.max(...arr);
  var min = Math.min(...arr);
  var candidate = max;

  var smallestCommon = function(low, high) {
    // inner function to use 'high' variable
    function scm(l, h) {
      if (h % l === 0) {
        return h;
      } else {
        return scm(l, h + high);
      }
    }
    return scm(low, high);
  };

  for (var i = min; i <= max; i += 1) {
    candidate = smallestCommon(i, candidate);
  }

  return candidate;
}

smallestCommons([5, 1]); // should return 60
smallestCommons([1, 13]); // should return 360360
smallestCommons([23, 18]); //should return 6056820

function smallestCommons(arr) {
  var min = Math.min(arr[0], arr[1]);
  var max = Math.max(arr[0], arr[1]);

  var smallestCommon = min * max;

  var doneCalc = 0;

  while (doneCalc === 0) {
    for (var i = min; i <= max; i++) {
      if (smallestCommon % i !== 0) {
        smallestCommon += max;
        doneCalc = 0;
        break;
      }
      else {
        doneCalc = 1;
      }
    }
  }

  return smallestCommon;
}

function smallestCommons(arr) {
  var biggestNum = arr[0];
  var smallestNum = arr[1];
  var thirdNum;
  //make sure biggestNum is always the largest
  if (biggestNum < smallestNum) {
    thirdNum = biggestNum;
    biggestNum = smallestNum;
    smallestNum = thirdNum;
  }
  var arrNum = [];
  var count = 0;
  var y = biggestNum;

  // making array with all the numbers fom smallest to biggest
  for (var i = smallestNum; i <= biggestNum; i += 1) {
    arrNum.push(i);
  }

  for (var z = 0; z <= arrNum.length; z += 1) {
    //noprotect
    for (y; y < 10000000; y += 1) {
      if (y % arrNum[z] === 0) {
        count += 1;
        break;
      }
      else if (count === arrNum.length) {
        console.log(y);
        return y;
      }
      else {
        count = 0;
        z = 0;
      }
    }
  }
}
smallestCommons([23, 18]);

function smallestCommons(arr) {
  var sortedArr = arr.sort(); // sort array first
  var tempArr = []; // create an empty array to store the array range
  var a = sortedArr[0];
  var b = sortedArr[1];
  for(var i = a; i <= b; i++){
    tempArr.push(i);
  }
  // find the lcm of 2 nums using the Euclid's algorithm
  function gcd(a, b){
    while (b){
      var temp = b;
      b = a % b;
      a = temp;
    }
    return a;
  }

  function lcm(a, b){
    return Math.abs((a * b) / gcd(a, b));
  }
  var lcmRange = tempArr.reduce(lcm);


  return lcmRange;
}

function smallestCommons(arr) {
    let smallest, biggest, min;
    arr.reduce(function (a, b) {
        biggest = Math.max(a, b);
    });
    const max = biggest;
    arr.reduce(function (a, b) {
        smallest = Math.min(a, b);
        min = smallest;
    });
    check: while (true) {
        biggest += max;
        for (min = smallest; min < max; min++) {
            if (biggest % min != 0) {
                continue check;
            }
            if (min == (max - 1) && biggest % min == 0) {
                console.warn('found one');
                return biggest;
            }
        }
    }
}

function smallestCommons(arr) {
  let smallestNum = arr[0] < arr[1] ? arr[0] : arr[1];
  let greatestNum = arr[0] > arr[1] ? arr[0] : arr[1];
  let initalsArr = [];
  for(let i = smallestNum; i <= greatestNum; i++){
    initalsArr.push(i);
  }
  let notFoundFlag = true;
  let gNMltpl = 0;
  let filteredArrLen; 
  while(notFoundFlag){
    gNMltpl += greatestNum;
    filteredArrLen = initalsArr.filter((num)=>{
      return (gNMltpl / num) === Math.floor((gNMltpl / num)) 
    }).length;
    if(initalsArr.length == filteredArrLen){
      notFoundFlag = false;
    }
  }
  return gNMltpl;
}

  const gcd = (a, b) => (!b ? a : gcd(b, a % b));

  const lcm = (a, b) => a * (b / gcd(a, b));

  const getLcm = (arr) => {

    const numbers = arr.sort((a, b) => parseInt(a) - parseInt(b));

    let result = parseInt(numbers[0]);

    for (let i = 1; i < numbers.length; i++) {
      result = lcm(parseInt(result), parseInt(numbers[i + 1]));
    }

    return result;
  };

  const getHcf = (arr) => {

    const numbers = arr.sort((a, b) => parseInt(a) - parseInt(b));

    let result = parseInt(numbers[0]);

    for (let i = 1; i < numbers.length; i++) {
      result = gcd(parseInt(numbers[i]), parseInt(result));
    }

    return result;
  };

  console.log(getLcm([20, 15, 10, 40])). Answer 120

  console.log(getHcf([2, 4, 6, 8, 16])). Answer 2

const leastCommonMultiple = (a, b) => (a * b) / greatestCommonDivisor(a, b);

const greatestCommonDivisor = (a, b) => {
  const remainder = a % b;
  if (remainder === 0) return b;
  return greatestCommonDivisor(b, remainder);
};

 var a = [2, 6];
    
    function getTotalX(a) {
      var num = 1e15;
      var i; 
      var arr = [];
      for (i = 1; i <=num ; i++){
        arr.push(i);
      }
     
      for (i = 0; i < a.length; i++){
        var filterArr = arr.filter((val, ind, arr) => (val % a[i] === 0));
      }
      
     console.log(filterArr[0]); // will return 6
      
    }

function findLowestCommonMultipleBetween(start: number, end: number): number {
  let numbers: number[] = [];

  for (let i = start; i <= end; i++) {
    numbers.push(i);
  }

  for (let i = 1; true; i++) {
    let divisor = end * i;

    if (numbers.every((number) => divisor % number == 0)) {
      return divisor;
    }
  }
}

function smallestCommons(arr) {
    let min = Math.min(...arr);
    let max = Math.max(...arr);
    let rangArr = [];
    for(let i = min; i <= max; i++) rangArr.push(i);
    let smallestCommon = max;
    while(!rangArr.every(e => smallestCommon % e === 0)){
        smallestCommon += max;
    }
    return smallestCommon;
}


console.log(smallestCommons([1, 13]));