Javascript 可数不可分余度问题的求解

我在讨论可分性问题，我在讨论“可数不可分”问题。我试过它的工作方式，但一点效率都没有

我发现答案没有任何解释，所以如果有人能花点时间，带我看完这个答案，我将不胜感激

function solution(A) {
    const lenOfA = A.length
    const counters = Array(lenOfA*2 + 1).fill(0)
    for(let j = 0; j<lenOfA; j++) counters[A[j]]++;
    
    return A.map(number=> {
        let nonDivisor = lenOfA
        for(let i = 1; i*i <= number; i++) {
            if(number % i !== 0) continue;
            nonDivisor -= counters[i];
            if(i*i !== number) nonDivisor -= counters[number/i]
        }
        return nonDivisor
    })
}

编写一个函数：

function solution(A);

给定一个由N个整数组成的数组A，返回一个 表示非除数数量的整数

结果数组应作为整数数组返回

例如，假设： A[0]=3 A[1]=1 A[2]=2 A[3]=3 A[4]=6

函数应该返回[2,4,3,2,0]，如上所述

为以下假设编写有效的算法：

    N is an integer within the range [1..50,000];
    each element of array A is an integer within the range [1..2 * N].

---

以下是我可以解释上述解决方案的方法

根据质询描述，它表示数组的每个元素都在范围[1…2*N]内，其中N是数组的长度；这意味着数组中的任何元素都不能大于2*N

因此，创建了一个长度为2*N+1（最大索引等于数组中的最大可能值）的计数器数组，其中的每个元素都初始化为0，但给定数组中实际存在的元素除外，这些元素都设置为1

现在我们要遍历给定数组中的所有元素，假设每个数字都是非除数，然后用计数器数组中的除数减去假定的非除数，这将得到实际的非除数。在循环过程中，当数组中不存在的元素是一个除数时，0被减去（记住我们的初始化值），当我们遇到同样在数组中的除数时，我们减去1（记住我们的初始化值）。这是对数组中的每个元素执行的，以获得它们的每个非分频器计数

您发布的解决方案使用了map，这只是一种转换数组的简洁方法。也可以使用简单的for循环，这样更容易理解。这是上述解决方案的一个for循环变体

  function solution(A) {
    const lenOfA = A.length
    const counters = Array(lenOfA*2 + 1).fill(0)
    for(let i = 0; i<lenOfA; i++) counters[A[i]]++;

    const arrayOfNondivisors = [];

    for(let i = 0; i < A.length; i++) {
      let nonDivisor = lenOfA
        for(let j = 1; j*j <= A[i]; j++) {
            if(A[i] % j !== 0) continue;
            nonDivisor -= counters[j];
            if(j*j !== A[i]) nonDivisor -= counters[A[i]/j]
        }
        arrayOfNondivisors.push(nonDivisor);
    }
    
    return arrayOfNondivisors;
}

函数解决方案（A）{
常数lenOfA=A.长度
常量计数器=数组（lenOfA*2+1）。填充（0）
for（设i=0；i
  function solution(A) {
    const lenOfA = A.length
    const counters = Array(lenOfA*2 + 1).fill(0)
    for(let i = 0; i<lenOfA; i++) counters[A[i]]++;

    const arrayOfNondivisors = [];

    for(let i = 0; i < A.length; i++) {
      let nonDivisor = lenOfA
        for(let j = 1; j*j <= A[i]; j++) {
            if(A[i] % j !== 0) continue;
            nonDivisor -= counters[j];
            if(j*j !== A[i]) nonDivisor -= counters[A[i]/j]
        }
        arrayOfNondivisors.push(nonDivisor);
    }
    
    return arrayOfNondivisors;
}