Question

我试图编写一个带两个数字并返回最小公倍数的函数，该公共倍数也可被这些数字之间的所有数字整除，我只能使用1,1到1 ，12，但由于某种原因停止工作在1,13。其他设置如12,14工作，但我无法弄清楚为什么或模式是什么。

function smallestCommons(arr) {
    arr.sort(function(a, b) {
        return a-b;
    });
    var arr1 = []; 
    var arr2 = [];
    for (var k = arr[0]; k<=arr[1]; k++) {
        arr1.push(k);
    }
    function remainder(val1, val2) {
        return val1%val2; 
    }
    var b = arr1.reduce(function(a, b) {
        return a*b; 
    });
    var i = arr1[arr1.length-1]*arr1[arr1.length-2];
    while (i<=b) {   
        for (var m = 0; m<arr1.length; m++) {
            var a = remainder(i, arr1[m]);
            arr2.push(a);
        }
        var answer = arr2.reduce(function(c, d) {
           return c+d;
        });
        if (answer === 0) { 
            return i;
        } else {
            arr2 = [];
            i++;
        }
    }  
}

Answer 1

我猜您可以在JavaScript中执行以下操作;它可以计算最多216个项目数组的公共LCM，例如[1,2,3,...,216]，小于0.25毫秒。

function gcd(a,b){
  var t = 0;
  a < b && (t = b, b = a, a = t); // swap them if a < b
  t = a%b;
  return t ? gcd(b,t) : b;
}

function lcm(a,b){
  return a/gcd(a,b)*b;
}

var arr = [1,2,3,4,5,6,7,8,9,10,11,12,13],
    brr = Array(216).fill().map((_,i) => i+1), // limit before Infinity
 result = arr.reduce(lcm);
console.log(result);
console.time("limit");
result = brr.reduce(lcm);
console.timeEnd("limit");
console.log(result);

Answer 2

一种方法是将范围内的最大数与不断增加的数相乘，然后检查是否所有其他数都可以被该数整除。如果是，则返回或继续循环。

这是我在打字稿中的解决方案...

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

...但对于更大的范围，this 是一个更有效的答案:)

Answer 3

这是真的！ [1,13]的结果是360360.在此之后我们有[1,14]。

14 = 2 * 7我们现在360360可分为2和7，所以答案又是360360。

[1,15]：15 = 3 * 5，结果相同。

[1,16]：结果是720720。

[1,17]：结果是：12252240

[1,18]：18 = 2 * 9，结果为12252240，与17

相同

[1,19]：对于我的电脑来说，这个过程非常繁重，无法做到这一点。但是在强大的机器中，它会起作用。我承诺。但是你的代码性能不佳。

Answer 4

据我所知，你的算法正在给你一个正确答案。

我远非专业程序员，所以任何想要的人都可以选择改进我的代码或风格：）

如果您希望能够自己检查答案，可以查看这个小提琴： https://jsfiddle.net/cowCrazy/Ld8khrx7/

function multiplyDict(arr) {
  arr.sort(function (a, b) {
    return a - b;
  });

  if (arr[0] === 1) {
    arr[0] = 2;
  }
  var currentArr = [];

  for (var i = arr[0]; i <= arr[1]; i++) {
    currentArr.push(i);
  }  
  var primeDivs = allPrimes(arr[1]);  
  var divsDict = {};

  for (var j = currentArr[0]; j <= currentArr[currentArr.length -1]; j++){
    divsDict[j] = [];
    if (primeDivs.indexOf(j) > -1) {
      divsDict[j].push(j);
    } else {
      var x = j;
      for (var n = 2; n <= Math.floor(j / 2); n++) {
        if (x % n === 0) {
          divsDict[j].push(n);
          x = x / n;
          n--;
          continue;
        }
      }
    }
  }
  return divsDict;
}

function allPrimes(num) {
  var primeArr = [];

  var smallestDiv = 2;

  loopi:
  for (var i = 2; i <= num; i++) {
    loopj:
    for (var j = smallestDiv; j <= largestDiv(i); j++) {
      if (i % j === 0) {
        continue loopi;
      }
    }
    primeArr.push(i);
  }  
  return primeArr;
}

function largestDiv (a) {
  return Math.floor(Math.sqrt(a));
}

multiplyDict([1,13]);

它给出了所请求数组的字典和每个元素的除数。从那里你可以自己去检查你的算法是否做得对，或者你可以在这里检查： https://jsfiddle.net/cowCrazy/kr04mas7/

我希望它有所帮助

Answer 5

以N个数字查找LCM。它与ES6兼容，并考虑到在需要查找大量数字的情况下无法控制边界。

var a = [10, 40, 50, 7];
console.log(GetMinMultiple(a));

function GetMinMultiple(data) {
    var maxOf = data.reduce((max, p) => p > max ? p : max, 0);
    var incremental = maxOf;
    var found = false;
    do {
        for (var j = 0; j < data.length; j++) {
            if (maxOf % data[j] !== 0) {
                maxOf += incremental;
                break;
            }
            else {
                if (j === data.length - 1) {
                    found = true;
                    break;
                }
            }
        }
    } while (!found);
    return maxOf;
}

https://jsfiddle.net/djp30gfz/

Answer 6

这是我在Typescript中的解决方案

function greatestCommonDivider(x: number, y: number): number {
  if (y === 0) {
    return x;
  }

  return greatestCommonDivider(y, x % y);
}

function singleLowestCommonMultiply(x: number, y: number): number {
  return (x * y) / greatestCommonDivider(x, y);
}

function lowestCommonMultiply(...numbers: number[]): number {
  /**
   * For each number, get it's lowest common multiply with next number.
   * 
   * Then using new number, compute new lowest common multiply
   */
  return numbers.reduce((a, b) => {
    return singleLowestCommonMultiply(a, b);
  });
}

lowestCommonMultiply(2, 3); // Outputs 6
lowestCommonMultiply(2, 3, 5); // Outputs 30

游乐场-click here

Javascript最常见的多重算法

6 个答案: