Javascript 读取二维阵列行为问题？

测试用例：

(6, [1,3,2,6,1,2]) returns (pairs / 2) = 5

它确实得到了答案，事情是这样做的比它需要做的更多，可能只是添加一些验证，以知道他何时添加相同的反向索引，但这只会给它更多的事情要做。我希望删除不必要的工作。它能更可靠吗

function returnOcurrences(k,ar){
    debugger;
    const letters = [new Set(ar)];
    let pairs = 0;

    for (let i = 0; i < ar.length; i++) {
        for (let ii = 0; ii < ar.length; ii++) {
            let a = ar[i] + ar[ii];
            if (i != ii) {
                if (a >= k) {
                    pairs += (a % k == 0) ? 1 : 0
                }
            }
        }
    }
    return pairs/2;
}

函数返回事件（k，ar）{
调试器；
常量字母=[新集合（ar）]；
设对=0；
for（设i=0；i=k）{
配对+=（a%k==0）？1:0
}
}
}
}
返回对/2；
}

我假设您要做的是阻止算法检查，例如，

ar[1]+ar[2]

，然后再次检查

ar[2]+ar[1]

为了解决这个问题，请考虑从<代码> i + 1 开始您的内部循环，而不是从0开始。这可以防止出现上述情况，也可以防止算法将元素与自身相加（例如，

ar[0]+ar[0]

）。因此，无需再检查

i

是否等于

ii

为什么会这样？假设外部循环的第一次迭代。您正在用

ar[1]

检查ar[0]的和，然后用

ar[2]

，

ar[3]

等检查

在外循环的第二次迭代中，您将检查

ar[1]

与数组中其他元素的和。但是，您已经在上一次迭代中选中了

ar[0]

+

ar[1]

。因此您从

ar[1]

+

ar[2]

开始，其中

ii=i+1=2

因此，代码变成：

function returnOcurrences(k,ar){
    const letters = [new Set(ar)]; //I don't see the purpose of this variable but okay
    var pairs = 0;

    for (var i = 0; i < ar.length; i++) {
        for (var ii = i + 1; ii < ar.length; ii++) {
            var a = ar[i] + ar[ii];
                if (a >= k) {
                    pairs += (a % k == 0) ? 1 : 0
                }
        }
    }
    return pairs/2;
} 

函数返回事件（k，ar）{
const letters=[new Set（ar）]；//我看不出这个变量的用途，但可以
var对=0；
对于（变量i=0；i=k）{
配对+=（a%k==0）？1:0
}
}
}
返回对/2；
} 

希望这有帮助