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