Test results - Codility

Tasks Details

medium

1. NumberOfDiscIntersections

Compute the number of intersections in a sequence of discs.

Task Score

100%

Correctness

100%

Performance

100%

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].

Solution

Programming language used JavaScript

Time spent on task 47 minutes

Notes

not defined yet

Code: 15:01:15 UTC, java, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public int solution(int[] A) {
        // write your code in Java SE 8
    }
}

Code: 15:01:20 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
}

Code: 15:27:40 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const 
}

Code: 15:28:00 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        
    }
}

Code: 15:28:10 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        if (ma)
    }
}

Code: 15:28:41 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const open = A[i] -
    }
}

Code: 15:29:00 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if ()
    }
}

Code: 15:29:20 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 1
            }
        }
    }
}

Code: 15:29:50 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        }
    }
}

Code: 15:30:11 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }

    Object.
}

Code: 15:30:27 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }

    Object.entries(map).sort()
}

Code: 15:31:24 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }

    
}

Code: 15:31:55 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }

    for (let key of Object.keys(map).sort((a, b) => a ))
}

Code: 15:32:03 UTC, js, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }

    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        console.log(key);
    }
}

Analysis

expand all Example tests

▶

example1
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.124 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, integer expected, 'undefined' found
Perhaps you are missing a 'return'?

stdout:

Code: 15:32:26 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }

    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        console.log(key);
    }
}

Code: 15:32:36 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }

    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        if (map)
    }
}

Code: 15:32:48 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }

    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        opened = opened + map
    }
}

Code: 15:33:12 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }

    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];

        intersections += 
    }
}

Code: 15:33:22 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }

    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];

        intersections += value.open
    }
}

Code: 15:33:44 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }

    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];

        intersections += value.open * opened;
        opened += value.open - value.close;
    }
}

Code: 15:34:03 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }

    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];

        intersections += value.open * opened;
        opened += value.open - value.close;

        if (intersections > 10000000) {
            return -;
        }
    }
}

Code: 15:34:07 UTC, js, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }

    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];

        intersections += value.open * opened;
        opened += value.open - value.close;

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Analysis

expand all Example tests

▶

example1
example test

✘

WRONG ANSWER
got 10 expected 11

0.072 s

WRONG ANSWER, got 10 expected 11

Code: 15:34:33 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }

    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];

        intersections += (value.open - value.close) * opened;
        opened += value.open - value.close;

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Code: 15:34:38 UTC, js, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }

    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];

        intersections += (value.open - value.close) * opened;
        opened += value.open - value.close;

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Analysis

expand all Example tests

▶

example1
example test

✘

WRONG ANSWER
got -7 expected 11

0.072 s

WRONG ANSWER, got -7 expected 11

Code: 15:34:49 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }

    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];

        intersections += value.open * opened;
        opened += value.open - value.close;

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Code: 15:35:47 UTC, js, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }

    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];

        intersections += value.open * opened;
        opened += value.open - value.close;

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Analysis

expand all Example tests

▶

example1
example test

✘

WRONG ANSWER
got 10 expected 11

0.072 s

WRONG ANSWER, got 10 expected 11

Code: 15:36:33 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }

    co

    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];

        intersections += value.open * opened;
        opened += value.open - value.close;

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Code: 15:36:40 UTC, js, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }

    console.log(map);

    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];
        console.log(value);

        intersections += value.open * opened;
        opened += value.open - value.close;

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Analysis

expand all Example tests

▶

example1
example test

✘

WRONG ANSWER
got 10 expected 11

0.076 s

WRONG ANSWER, got 10 expected 11

stdout:

{ '0': { open: 2, close: 0 },
  '1': { open: 0, close: 1 },
  '2': { open: 1, close: 0 },
  '4': { open: 0, close: 2 },
  '5': { open: 1, close: 1 },
  '6': { open: 0, close: 1 },
  '8': { open: 0, close: 1 },
  '-1': { open: 1, close: 0 },
  '-4': { open: 1, close: 0 } }
{ open: 1, close: 0 }
{ open: 1, close: 0 }
{ open: 2, close: 0 }
{ open: 0, close: 1 }
{ open: 1, close: 0 }
{ open: 0, close: 2 }
{ open: 1, close: 1 }
{ open: 0, close: 1 }
{ open: 0, close: 1 }

Code: 15:37:01 UTC, js, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }

    console.log(map);

    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];

        intersections += value.open * opened;
        opened += value.open - value.close;

        console.log(intersections);
        console.log(opened);

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Analysis

expand all Example tests

▶

example1
example test

✘

WRONG ANSWER
got 10 expected 11

0.076 s

WRONG ANSWER, got 10 expected 11

stdout:

{ '0': { open: 2, close: 0 },
  '1': { open: 0, close: 1 },
  '2': { open: 1, close: 0 },
  '4': { open: 0, close: 2 },
  '5': { open: 1, close: 1 },
  '6': { open: 0, close: 1 },
  '8': { open: 0, close: 1 },
  '-1': { open: 1, close: 0 },
  '-4': { open: 1, close: 0 } }
0
1
1
2
5
4
5
3
8
4
8
2
10
2
10
1
10
0

Code: 15:37:36 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }


    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];

        intersections += value.open * opened;
        opened += value.open - value.close;

        console.log(intersections);
        console.log(opened);

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Code: 15:37:46 UTC, js, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }

    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];
        console.log(key)
        console.log(value);
        

        intersections += value.open * opened;
        opened += value.open - value.close;

        console.log(intersections);
        console.log(opened);

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Analysis

expand all Example tests

▶

example1
example test

✘

WRONG ANSWER
got 10 expected 11

0.076 s

WRONG ANSWER, got 10 expected 11

stdout:

-4
{ open: 1, close: 0 }
0
1
-1
{ open: 1, close: 0 }
1
2
0
{ open: 2, close: 0 }
5
4
1
{ open: 0, close: 1 }
5
3
2
{ open: 1, close: 0 }
8
4
4
{ open: 0, close: 2 }
8
2
5
{ open: 1, close: 1 }
10
2
6
{ open: 0, close: 1 }
10
1
8
{ open: 0, close: 1 }
10
0

Code: 15:42:04 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }



    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];
        console.log(key)
        console.log(value);
        

        intersections += value.open * opened;
        opened += value.open - value.close;

        console.log(intersections);
        console.log(opened);

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Code: 15:42:14 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }
/*
 * 0 and 1,
 * 0 and 2,
 * 0 and 4,
 * 1 and 2,
 * 1 and 3,
 * 1 and 4,
 * 1 and 5,
 * 2 and 3,
 * 2 and 4,
 * 3 and 4,
 * 4 and 5.
*/
    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];
        console.log(key)
        console.log(value);
        

        intersections += value.open * opened;
        opened += value.open - value.close;

        console.log(intersections);
        console.log(opened);

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Code: 15:42:38 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }
/*
 * 0 and 1, ok
 * 0 and 2,
 * 0 and 4,
 * 1 and 2,
 * 1 and 3,
 * 1 and 4,
 * 1 and 5,
 * 2 and 3,
 * 2 and 4,
 * 3 and 4,
 * 4 and 5.
*/
    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];
        console.log(key)
        console.log(value);
        

        intersections += value.open * opened;
        opened += value.open - value.close;

        console.log(intersections);
        console.log(opened);

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Code: 15:43:08 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }
/*
 * 0 and 1, ok
 * 0 and 2, ok
 * 0 and 4,
 * 1 and 2,
 * 1 and 3,
 * 1 and 4,
 * 1 and 5,
 * 2 and 3,
 * 2 and 4,
 * 3 and 4,
 * 4 and 5.
*/
    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];
        console.log(key)
        console.log(value);
        

        intersections += value.open * opened;
        opened += value.open - value.close;

        console.log(intersections);
        console.log(opened);

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Code: 15:43:18 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }
/*
 * 0 and 1, ok
 * 0 and 2, ok
 * 0 and 4, ok
 * 1 and 2,
 * 1 and 3,
 * 1 and 4,
 * 1 and 5,
 * 2 and 3,
 * 2 and 4,
 * 3 and 4,
 * 4 and 5.
*/
    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];
        console.log(key)
        console.log(value);
        

        intersections += value.open * opened;
        opened += value.open - value.close;

        console.log(intersections);
        console.log(opened);

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Code: 15:43:29 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }
/*
 * 0 and 1, ok
 * 0 and 2, ok
 * 0 and 4, ok
 * 1 and 2, ok
 * 1 and 3,
 * 1 and 4, ok
 * 1 and 5,
 * 2 and 3,
 * 2 and 4,
 * 3 and 4,
 * 4 and 5.
*/
    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];
        console.log(key)
        console.log(value);
        

        intersections += value.open * opened;
        opened += value.open - value.close;

        console.log(intersections);
        console.log(opened);

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Code: 15:43:50 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }
/*
 * 0 and 1, ok
 * 0 and 2, ok
 * 0 and 4, ok
 * 1 and 2, ok
 * 1 and 3, ok
 * 1 and 4, ok
 * 1 and 5,
 * 2 and 3,
 * 2 and 4,
 * 3 and 4,
 * 4 and 5.
*/
    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];
        console.log(key)
        console.log(value);
        

        intersections += value.open * opened;
        opened += value.open - value.close;

        console.log(intersections);
        console.log(opened);

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Code: 15:44:06 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }
/*
 * 0 and 1, ok
 * 0 and 2, ok
 * 0 and 4, ok
 * 1 and 2, ok
 * 1 and 3, ok
 * 1 and 4, ok
 * 1 and 5,
 * 2 and 3, 
 * 2 and 4, ok
 * 3 and 4,
 * 4 and 5.
*/
    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];
        console.log(key)
        console.log(value);
        

        intersections += value.open * opened;
        opened += value.open - value.close;

        console.log(intersections);
        console.log(opened);

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Code: 15:44:18 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }
/*
 * 0 and 1, ok
 * 0 and 2, ok
 * 0 and 4, ok
 * 1 and 2, ok
 * 1 and 3,
 * 1 and 4, ok
 * 1 and 5,
 * 2 and 3,
 * 2 and 4,
 * 3 and 4,
 * 4 and 5.
*/
    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];
        console.log(key)
        console.log(value);
        

        intersections += value.open * opened;
        opened += value.open - value.close;

        console.log(intersections);
        console.log(opened);

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Code: 15:44:34 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }
/*
 * 0 and 1, ok
 * 0 and 2, ok
 * 0 and 4, ok
 * 1 and 2, ok
 * 1 and 3, ok
 * 1 and 4, ok
 * 1 and 5,
 * 2 and 3,
 * 2 and 4,
 * 3 and 4,
 * 4 and 5.
*/
    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];
        console.log(key)
        console.log(value);
        

        intersections += value.open * opened;
        opened += value.open - value.close;

        console.log(intersections);
        console.log(opened);

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Code: 15:44:45 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }
/*
 * 0 and 1, ok
 * 0 and 2, ok
 * 0 and 4, ok
 * 1 and 2, ok
 * 1 and 3, ok
 * 1 and 4, ok
 * 1 and 5,
 * 2 and 3, ok 
 * 2 and 4,
 * 3 and 4, ok
 * 4 and 5.
*/
    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];
        console.log(key)
        console.log(value);
        

        intersections += value.open * opened;
        opened += value.open - value.close;

        console.log(intersections);
        console.log(opened);

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Code: 15:45:28 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }
/*
 * 0 and 1, ok
 * 0 and 2, ok
 * 0 and 4, ok
 * 1 and 2, ok
 * 1 and 3, ok
 * 1 and 4, ok
 * 1 and 5, 
 * 2 and 3, ok 
 * 2 and 4,
 * 3 and 4, ok
 * 4 and 5.
*/
    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];
        console.log(key)
        console.log(value);
        

        intersections += value.open * opened;
        opened += value.open - value.close;

        console.log(intersections);
        console.log(opened);

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Code: 15:45:41 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }
/*
 * 0 and 1, ok
 * 0 and 2, ok
 * 0 and 4, ok
 * 1 and 2, ok
 * 1 and 3, ok
 * 1 and 4, ok
 * 1 and 5, ok
 * 2 and 3, ok 
 * 2 and 4,
 * 3 and 4, ok
 * 4 and 5.
*/
    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];
        console.log(key)
        console.log(value);
        

        intersections += value.open * opened;
        opened += value.open - value.close;

        console.log(intersections);
        console.log(opened);

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Code: 15:45:52 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }
/*
 * 0 and 1, ok
 * 0 and 2, ok
 * 0 and 4, ok
 * 1 and 2, ok
 * 1 and 3, ok
 * 1 and 4, ok
 * 1 and 5, ok
 * 2 and 3, ok 
 * 2 and 4,
 * 3 and 4, ok
 * 4 and 5. ok
*/
    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];
        console.log(key)
        console.log(value);
        

        intersections += value.open * opened;
        opened += value.open - value.close;

        console.log(intersections);
        console.log(opened);

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Code: 15:46:37 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }
/*
 * 0 and 1, ok
 * 0 and 2, ok
 * 0 and 4, ok
 * 1 and 2, ok
 * 1 and 3, ok
 * 1 and 4, ok
 * 1 and 5, ok
 * 2 and 3, ok 
 * 2 and 4,
 * 3 and 4, ok
 * 4 and 5. ok
*/
    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];
        console.log(key)
        console.log(value);
        



        intersections += value.open * opened;
        opened += value.open - value.close;

        console.log(intersections);
        console.log(opened);

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Code: 15:47:08 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }
/*
 * 0 and 1, ok
 * 0 and 2, ok
 * 0 and 4, ok
 * 1 and 2, ok
 * 1 and 3, ok
 * 1 and 4, ok
 * 1 and 5, ok
 * 2 and 3, ok 
 * 2 and 4,
 * 3 and 4, ok
 * 4 and 5. ok
*/
    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];
        console.log(key)
        console.log(value);
        
        for (let j = 0; j < value.open; j++) {
            intersections += value.open * opened;
        }
        
        opened += value.open - value.close;

        console.log(intersections);
        console.log(opened);

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Code: 15:47:33 UTC, js, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }
/*
 * 0 and 1, ok
 * 0 and 2, ok
 * 0 and 4, ok
 * 1 and 2, ok
 * 1 and 3, ok
 * 1 and 4, ok
 * 1 and 5, ok
 * 2 and 3, ok 
 * 2 and 4,
 * 3 and 4, ok
 * 4 and 5. ok
*/
    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];
        console.log(key)
        console.log(value);
        
        for (let j = 0; j < value.open; j++) {
            intersections += opened;
            opened += value.open;
        }

        opened -= value.close;

        console.log(intersections);
        console.log(opened);

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Analysis

expand all Example tests

▶

example1
example test

✘

WRONG ANSWER
got 16 expected 11

0.076 s

WRONG ANSWER, got 16 expected 11

stdout:

-4
{ open: 1, close: 0 }
0
1
-1
{ open: 1, close: 0 }
1
2
0
{ open: 2, close: 0 }
7
6
1
{ open: 0, close: 1 }
7
5
2
{ open: 1, close: 0 }
12
6
4
{ open: 0, close: 2 }
12
4
5
{ open: 1, close: 1 }
16
4
6
{ open: 0, close: 1 }
16
3
8
{ open: 0, close: 1 }
16
2

Code: 15:47:50 UTC, js, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }
/*
 * 0 and 1, ok
 * 0 and 2, ok
 * 0 and 4, ok
 * 1 and 2, ok
 * 1 and 3, ok
 * 1 and 4, ok
 * 1 and 5, ok
 * 2 and 3, ok 
 * 2 and 4,
 * 3 and 4, ok
 * 4 and 5. ok
*/
    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];
        console.log(key)
        console.log(value);
        
        for (let j = 0; j < value.open; j++) {
            intersections += opened;
            opened ++
        }

        opened -= value.close;

        console.log(intersections);
        console.log(opened);

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Code: 15:47:52 UTC, js, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }
/*
 * 0 and 1, ok
 * 0 and 2, ok
 * 0 and 4, ok
 * 1 and 2, ok
 * 1 and 3, ok
 * 1 and 4, ok
 * 1 and 5, ok
 * 2 and 3, ok 
 * 2 and 4,
 * 3 and 4, ok
 * 4 and 5. ok
*/
    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];
        console.log(key)
        console.log(value);
        
        for (let j = 0; j < value.open; j++) {
            intersections += opened;
            opened++;
        }

        opened -= value.close;

        console.log(intersections);
        console.log(opened);

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Analysis

expand all Example tests

▶

example1
example test

✔

0.076 s

stdout:

-4
{ open: 1, close: 0 }
0
1
-1
{ open: 1, close: 0 }
1
2
0
{ open: 2, close: 0 }
6
4
1
{ open: 0, close: 1 }
6
3
2
{ open: 1, close: 0 }
9
4
4
{ open: 0, close: 2 }
9
2
5
{ open: 1, close: 1 }
11
2
6
{ open: 0, close: 1 }
11
1
8
{ open: 0, close: 1 }
11
0

Code: 15:48:04 UTC, js, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }

    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];
        
        for (let j = 0; j < value.open; j++) {
            intersections += opened;
            opened++;
        }

        opened -= value.close;

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Analysis

expand all Example tests

▶

example1
example test

✔

0.072 s

Code: 15:48:07 UTC, js, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }

    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];
        
        for (let j = 0; j < value.open; j++) {
            intersections += opened;
            opened++;
        }

        opened -= value.close;

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Analysis

expand all Example tests

▶

example1
example test

✔

0.072 s

Code: 15:48:09 UTC, js, final, score: 100

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    const N = A.length;
    const map = {};

    for (let i = 0; i < N; i++) {
        const openAt = i - A[i];
        const closeAt = A[i] + i;

        if (!map[openAt]) {
            map[openAt] = {
                open: 1,
                close: 0
            }
        } else {
            map[openAt].open++;
        }

        if (!map[closeAt]) {
            map[closeAt] = {
                open: 0,
                close: 1
            }
        } else {
             map[closeAt].close++;
        }
    }

    let opened = 0;
    let intersections = 0;
    for (let key of Object.keys(map).sort((a, b) => a - b)) {
        const value = map[key];
        
        for (let j = 0; j < value.open; j++) {
            intersections += opened;
            opened++;
        }

        opened -= value.close;

        if (intersections > 10000000) {
            return -1;
        }
    }

    return intersections;
}

Analysis summary

The solution obtained perfect score.

Analysis

Detected time complexity:

O(N*log(N)) or O(N)

expand all Example tests

▶

example1
example test

✔

0.072 s

expand all Correctness tests

▶

simple1

✔

0.072 s

▶

simple2

✔

0.072 s

▶

simple3

✔

0.072 s

▶

extreme_small
empty and [10]

✔

0.072 s

▶

small1

✔

0.072 s

▶

small2

✔

0.072 s

▶

small3

✔

0.072 s

▶

overflow
arithmetic overflow tests

✔

0.072 s

expand all Performance tests

▶

medium1

✔

0.084 s

▶

medium2

✔

0.092 s

▶

medium3

✔

0.100 s

▶

medium4

✔

0.116 s

▶

10M_intersections
10.000.000 intersections

✔

0.132 s

▶

big1

✔

0.184 s

0.072 s

▶

big2

✔

0.272 s

0.072 s

▶

big3
[0]*100.000

✔

0.296 s

0.072 s