Javascript 如何使下面的代码在性能方面更有效？

下面的代码比较两个数组，并检查两个数组上匹配索引处的元素是否具有相似的素因子。如果为真，则匹配因子（“匹配”）的计数增加1

/* eslint-disable no-console */
const primeFactors = (n) => {
  let number = n;
  const factors = [];
  let divisor = 2;

  while (number >= 2) {
    if (number % divisor === 0) {
      factors.push(divisor);
      number /= divisor;
    } else {
      divisor += 1;
    }
  }
  return factors;
};

const solution = (A, B) => {
  let matching = 0;

  for (let index = 0; index < A.length; index += 1) {
    const a = A[index];
    const b = B[index];

    let aFactors = primeFactors(a);
    aFactors = new Set(aFactors);
    aFactors = Array.from(aFactors);
    aFactors = aFactors.sort((first, second) => first - second);
    let bFactors = primeFactors(b);
    bFactors = new Set(bFactors);
    bFactors = Array.from(bFactors);
    bFactors = bFactors.sort((first, second) => first - second);

    if (JSON.stringify(aFactors) === JSON.stringify(bFactors)) {
      matching += 1;
    }
  }
  return matching;
};

如何使此算法更有效？目前，它的效率得分为84%，两次针对大型数据集的优化测试均未通过

将一个数组转换为一个集合，然后再转换回一个数组似乎是白费力气。为什么不在

primeFactors

中消除重复项呢

 while (number >= 2) {
     if (number % divisor === 0) {
         factors.push(divisor);
         while (number % divisor === 0) {
             number /= divisor;
         }
     } else {
         divisor += 1;
     }
 }

不需要按上述方式对获得的数组进行排序。它们已经分类了。也没有必要将其严格化。只需逐个元素进行比较

基本的加速来自这样一个观察：两个数字具有相同的素数成分，当且仅当它们的

gcd

具有相同的素数成分时。

gcd

非常容易计算；它往往比它的参数小得多，因此更容易分解。此外，它只需要一次分解，而不是解决方案中的两次分解。考虑

 same_prime_composition(a, b)
     g = gcd(a, b)
     primes = primeFactors(g)
     return is_decomposable(a/g, primes) && is_decomposable(b/g, primes)

 prime_decomposable(x, primes)
     for p in primes
         while (x % p == 0)
             x /= p
     return x === 1

事先计算素数可能是有益的

我不知道是否支持

divmod

。如果是这样的话，还有更大的优化空间

将一个数组转换为一个集合，然后再转换回一个数组似乎是白费力气。为什么不在

primeFactors

中消除重复项呢

 while (number >= 2) {
     if (number % divisor === 0) {
         factors.push(divisor);
         while (number % divisor === 0) {
             number /= divisor;
         }
     } else {
         divisor += 1;
     }
 }

不需要按上述方式对获得的数组进行排序。它们已经分类了。也没有必要将其严格化。只需逐个元素进行比较

基本的加速来自这样一个观察：两个数字具有相同的素数成分，当且仅当它们的

gcd

具有相同的素数成分时。

gcd

非常容易计算；它往往比它的参数小得多，因此更容易分解。此外，它只需要一次分解，而不是解决方案中的两次分解。考虑

 same_prime_composition(a, b)
     g = gcd(a, b)
     primes = primeFactors(g)
     return is_decomposable(a/g, primes) && is_decomposable(b/g, primes)

 prime_decomposable(x, primes)
     for p in primes
         while (x % p == 0)
             x /= p
     return x === 1

事先计算素数可能是有益的

我不知道是否支持

divmod

。如果是这样的话，还有更大的优化空间

---

快速加速是让PrimeFactors在sqrt（n）处停止。此时

number

的值必然是最后一个素数因子。

快速加速是使素数因子在sqrt（n）处停止。当时

number

的值必然是最后一个主要因素。

这里有很好的推荐。第三条建议和代码片段对我来说不是很清楚。请解释一下。这里有很好的推荐。第三条建议和代码片段对我来说不是很清楚。请解释一下。