Smallest Common Multiple

解法一：
function smallestCommons(arr){
　var tag;
  var max = arr[0]>arr[1]?arr[0]:arr[1];
  var min = arr[0]>arr[1]?arr[1]:arr[0];
  
  //给数组arr赋值。
　for(var i = 0;i<=max-min;i++){
    arr[i]=min+i; 
  }

  //判断某个数是否是质数。
  function isPrime(n){
    if(n === 1){
      return false;
    }else{
      for(var i =2;i<n;i++){
        if(n%i === 0){
          return false;
        }
      }
      return true;
    }  
  }
  var brr=[];
  
　//构造质数数组，质数数组最大值是传入数组的最大值。
　for(var j =2;j<=max;j++){
    if(isPrime(j)){
      brr.push(j);
    }
  }
 
　//从最大质数开始依次去除用传入数组构造的arr数组的每一项值，如果除完最小质数2后还未除尽，调用此函数。
  var crr=[];
  function mul(){
    for(var y =0;y<arr.length;y++){
      if(arr[y]%2 === 0){
        arr[y]=arr[y]/2;
        tag = true;
      }
    }
    if(tag){
      crr.push(2);
    }
  }
  
　　//从最大质数开始依次去除传入数组构造的arr数组的每一项值，如果有可除的数则将质数保存到crr中，并将arr中的值改除掉后的值。
    for(var x = brr.length-1;x>=0;x--){
    for(var y =0;y<arr.length;y++){
      if(arr[y]%brr[x] === 0){
        arr[y]=arr[y]/brr[x];
        tag = true;
      }
    }
   if(tag){
      crr.push(brr[x]);
   }
  }

　//判断是否除尽，如果只有两个质数（即2和3）表示已除尽。
  function isDown(b){
    var count;
    for(var z =0;z<b.length;z++){
      if (isPrime(b[z])){
        count += 1;
      }
    }
    if (count ===2){
      return true;
    }else{
      return false;
    }
  }

  if(!isDown(arr)){

　　mul(arr);

　　}


  var drr=arr.concat(crr);


  return drr.reduce(function(a,b){
    return a*b;
  });
}

 解法二：

function smallestCommons(arr) {
  var max = arr[0]>arr[1]?arr[0]:arr[1];
  var min = arr[0]>arr[1]?arr[1]:arr[0];
  var brr=[];
  function math(n){
     return n>1?n*math(n-1):1;
  }
  //return math(max);
  for(var j = min;j<=max;j++){
    for(var x=2;x<=math(max);x++){
      brr.push(j*x);
    }    
  }
  /*function compare(a,b){
    if(a<b){
      return -1;
    }else if(a>b){
      return 1;
    }else{
      return 0;
    }
  }
  brr.sort(compare);*/
  var count = 0;
  for(var i=0;i<brr.length;i++){
    var aa = brr[i];
    //return aa;
    for(var z=0;z<brr.length;z++){
      if(brr[z] === aa){
        count += 1;  
      }
    }
    /*if(brr[i] === brr[i+1]){
      count +=1;
    }else{
      count = 0;
    }*/
    if (count === max-min+1){
      return aa;
    }else{
      count= 0;
    }
  }
}

这种解法只适用于小数字，当求13个数的最小公倍数时，在第9行和第25行会出现无限循环。报错内容如下：

解法三：最大公约数法（此种最简便，速度最快）

function smallestCommons(array) {
    var range = createRange(array);

    return range.reduce(function(a, b) {
        return lcm(a, b);
    });

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

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

    function createRange(array) {
        var range = [];
        var highest = array.reduce(function(a, b) {
            return Math.max(a, b);
        });
        var lowest = array.reduce(function(a, b) {
            return Math.min(a, b);
        });
        for (var i = lowest; i <= highest; i++) {
            range.push(i);
        }
        return range;
    }
}