阅读二维数组行为问题？

Question

Test Cases:

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

It does get the answer the thing is that is doing more than it needs to, It is possible just add some validation to know when he is adding same reversed index but it will only give it more to do. am looking to remove the unneeded work. can it be more reliable?

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

Answer 1

What I assume you want to do is prevent the algorithm from checking eg ar[1] + ar[2] , then ar[2] + ar[1] again.

To solve this, consider starting your inner loop from i + 1 and not from 0. This prevents the mentioned scenario from happening, and also prevents the algorithm from summing an element with itself (eg ar[0] + ar[0] ). So no need to check anymore if i is equal to ii .

Why so? Assume the first iteration of the outer loop. You are checking the sum of ar[0] with ar[1] , then with ar[2] , ar[3] , and so on.

On the second iteration of the outer loop, you are checking sums of ar[1] with other elements of the array. However, you already checked ar[0] + ar[1] in the previous iteration. So you start with ar[1] + ar[2] , where ii = i + 1 = 2 .

So the code becomes:

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

Hope this helps!