Codility - NumberOfDiscIntersections

We draw N discs on a plane. The discs are numbered from 0 to N − 1. An array A of N non-negative integers, specifying the radiuses of the discs, is given. The J-th disc is drawn with its center at (J, 0) and radius A[J].
We say that the J-th disc and K-th disc intersect if J ≠ K and the J-th and K-th discs have at least one common point (assuming that the discs contain their borders).
The figure below shows discs drawn for N = 6 and A as follows:
A[0] = 1
A[1] = 5
A[2] = 2
A[3] = 1
A[4] = 4
A[5] = 0

There are eleven (unordered) pairs of discs that intersect, namely:
discs 1 and 4 intersect, and both intersect with all the other discs;
disc 2 also intersects with discs 0 and 3.
Write a function:
function solution(A);
that, given an array A describing N discs as explained above, returns the number of (unordered) pairs of intersecting discs. The function should return −1 if the number of intersecting pairs exceeds 10,000,000.
Given array A shown above, the function should return 11, as explained above.
Write an efficient algorithm for the following assumptions:
N is an integer within the range [0..100,000];
each element of array A is an integer within the range [0..2,147,483,647].
Copyright 2009–2021 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.

座標値のLeft値に準じ、範囲に属する場合はカウントします.(50%)

function solution(A) {
    let answer = new Set();
    let pair = [];
   A.map((ele, idx) => {
       let left = idx - ele;
       let right = idx + ele;
       pair.push({left: left, right: right});
   })

   pair.map((ele, idx) => {
       let current = ele;

       for (let j=0; j<pair.length; j++) {
           if (idx !== j) {
               if ((pair[j].left <= current.left && current.right <= pair[j].right)
                    || (current.left <= pair[j].left && pair[j].left <= current.right)) {
                
                let temp = idx + "/" + j;
                let reverse = j + "/" + idx;
                if (!answer.has(reverse)) {
                    answer.add(temp);
                }
               } 
           } else {
               continue;
           }
       }
   });
   return (answer.size > 10000000) ? -1 : answer.size;
}

座標値のRight値がLeft値以上である場合、カウント(100%)

を増加する.

function solution(A) {
    let pair = [];
   for(let i=0; i<A.length; i++){
        pair.push({l:i-A[i],r:i+A[i]});
    }
    
    pair.sort((a,b)=>a.l-b.l);

    let answer=0;
    for (let i=0; i<pair.length; i++) {
        for (let j=i+1; j<pair.length; j++) {
            if (pair[i].r >= pair[j].l) {
                answer++
            
            } else {
                break
            }

            if(answer > 10000000) return -1
        }
    }
   return answer
}