Test results - Codility

Tasks Details

medium

1. CountNonDivisible

Calculate the number of elements of an array that are not divisors of each element.

Task Score

100%

Correctness

100%

Performance

100%

You are given an array A consisting of N integers.

For each number A[i] such that 0 ≤ i < N, we want to count the number of elements of the array that are not the divisors of A[i]. We say that these elements are non-divisors.

For example, consider integer N = 5 and array A such that:

A[0] = 3 A[1] = 1 A[2] = 2 A[3] = 3 A[4] = 6

For the following elements:

A[0] = 3, the non-divisors are: 2, 6,

A[1] = 1, the non-divisors are: 3, 2, 3, 6,

A[2] = 2, the non-divisors are: 3, 3, 6,

A[3] = 3, the non-divisors are: 2, 6,

A[4] = 6, there aren't any non-divisors.

Write a function:

function solution(A);

that, given an array A consisting of N integers, returns a sequence of integers representing the amount of non-divisors.

Result array should be returned as an array of integers.

For example, given:

A[0] = 3 A[1] = 1 A[2] = 2 A[3] = 3 A[4] = 6

the function should return [2, 4, 3, 2, 0], as explained above.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..50,000];

each element of array A is an integer within the range [1..2 * N].

Solution

Programming language used JavaScript

Time spent on task 102 minutes

Notes

not defined yet

Code: 15:08:09 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:08:19 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: 16:39:01 UTC, js, autosave

show code in pop-up

1 2 3 4 5

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

function solution(A) {
}

Code: 16:39:32 UTC, js, autosave

show code in pop-up

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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (map[A[i]]) {
            map[A[i]]
        }
    }
}

Code: 16:39:48 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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
}

The submission is being evaluated.

Code: 16:40: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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const nu
}

Code: 16:40: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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);

    for (let i = 0; i < numbers.length; i++) {
        
    }
}

Code: 16:40:43 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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);
    for (let i = 0; i < numbers.length; i++) {
        
    }
}

Code: 16:41: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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);
    const ninDivisor
    for (let i = 0; i < numbers.length; i++) {

    }
}

Code: 16:41:32 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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        let nonDivisors = 0;

        for (let )
    }
}

Code: 16:41:56 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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        let nonDivisors = 0;
        let i = 0;
        
        while (i * i <= )
    }
}

Code: 16:42: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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        let nonDivisors = 0;
        let i = 0;
        
        while (i * i <= numbers[i]) {
            
        }
    }
}

Code: 16:42:21 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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        let nonDivisors = 0;
        let i = 0;
        
        while (i * i <= numbers[i]) {
            if (i % )

            i++;
        }
    }
}

Code: 16:42:54 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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        co
        let nonDivisors = 0;
        let i = 0;
        
        while (i * i <= numbers[i]) {
            if (i % )

            i++;
        }
    }
}

Code: 16: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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        const current = numbers[i];
        
        let nonDivisors = 0;
        let i = 0;
        
        while (i * i <= numbers[i]) {
            if (i % )

            i++;
        }
    }
}

Code: 16:43:19 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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        const current = numbers[i];

        let nonDivisors = 0;
        let i = 0;
        
        while (i * i <= current) {
            if (current % i === 0) {
                
            }

            i++;
        }
    }
}

Code: 16: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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        const current = numbers[i];

        let nonDivisors = 0;
        let i = 0;
        
        while (i * i <= current) {
            if (current % i === 0) {
                if (counts[i]) {
                    nonDivisors += counts[i];
                }
            }

            i++;
        }
    }
}

Code: 16:44:10 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        const current = numbers[i];

        let nonDivisors = 0;
        let i = 0;
        
        while (i * i <= current) {
            if (current % i === 0) {
                if (counts[i]) {
                    nonDivisors += counts[i];
                }

                if (n/i === i) {
                    
                }
            }

            i++;
        }
    }
}

Code: 16:44: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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        const current = numbers[i];

        let nonDivisors = 0;
        let i = 0;
        
        while (i * i <= current) {
            if (current % i === 0) {
                if (counts[i]) {
                    nonDivisors += counts[i];
                }

                if (n/i !== i) {
                    
                }
            }

            i++;
        }
    }
}

Code: 16:44:57 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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        const current = numbers[i];

        let nonDivisors = 0;
        let i = 0;
        
        while (i * i <= current) {
            if (current % i === 0) {
                if (counts[i]) {
                    nonDivisors += counts[i];
                }

                if (n/i !== i) {
                    if (counts[i]) {
                    nonDivisors += counts[i];
                }
                }
            }

            i++;
        }
    }
}

Code: 16:45: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 33 34 35 36 37 38 39 40 41 42

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        const current = numbers[i];

        let nonDivisors = 0;
        let i = 0;
        
        while (i * i <= current) {
            if (current % i === 0) {
                if (counts[i]) {
                    nonDivisors += counts[i];
                }

                const pairDivisor = 
                if (n/i !== i) {
                    if (counts[i]) {
                    nonDivisors += counts[i];
                }
                }
            }

            i++;
        }
    }
}

Code: 16:45: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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        const current = numbers[i];

        let nonDivisors = 0;
        let i = 0;
        
        while (i * i <= current) {
            if (current % i === 0) {
                if (counts[i]) {
                    nonDivisors += counts[i];
                }

                const divisorPair = n/i;
                if (divisorPair !== i) {
                    if (counts[divisorPair]) {
                        nonDivisors += counts[divisorPair];
                    }
                }
            }

            i++;
        }
    }
}

Code: 16:46:02 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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        const current = numbers[i];

        let divisors = 0;
        let i = 0;
        
        while (i * i <= current) {
            if (current % i === 0) {
                if (counts[i]) {
                    nonDivisors += counts[i];
                }

                const divisorPair = n/i;
                if (divisorPair !== i) {
                    if (counts[divisorPair]) {
                        nonDivisors += counts[divisorPair];
                    }
                }
            }

            i++;
        }
    }
}

Code: 16:46:16 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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        const current = numbers[i];

        let divisors = 0;
        let i = 0;
        
        while (i * i <= current) {
            if (current % i === 0) {
                if (counts[i]) {
                    divisors += counts[i];
                }

                const divisorPair = n/i;
                if (divisorPair !== i) {
                    if (counts[divisorPair]) {
                        divisors += counts[divisorPair];
                    }
                }
            }

            i++;
        }

        nonDivisors[]
    }
}

Code: 16:46: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 37 38 39 40 41 42 43 44

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        const current = numbers[i];

        let divisors = 0;
        let i = 0;
        
        while (i * i <= current) {
            if (current % i === 0) {
                if (counts[i]) {
                    divisors += counts[i];
                }

                const divisorPair = n/i;
                if (divisorPair !== i) {
                    if (counts[divisorPair]) {
                        divisors += counts[divisorPair];
                    }
                }
            }

            i++;
        }

        nonDivisors[current] = 
    }
}

Code: 16:46: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 46

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        const current = numbers[i];

        let divisors = 0;
        let i = 0;
        
        while (i * i <= current) {
            if (current % i === 0) {
                if (counts[i]) {
                    divisors += counts[i];
                }

                const divisorPair = n/i;
                if (divisorPair !== i) {
                    if (counts[divisorPair]) {
                        divisors += counts[divisorPair];
                    }
                }
            }

            i++;
        }

        nonDivisors[current] = N - divisors;
    }

    console.log(nonDivisors);
}

The submission is being evaluated.

Code: 16:46:57 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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        const current = numbers[i];

        let divisors = 0;
        let j = 0;
        
        while (j * j <= current) {
            if (current % j === 0) {
                if (counts[i]) {
                    divisors += counts[i];
                }

                const divisorPair = n/i;
                if (divisorPair !== i) {
                    if (counts[divisorPair]) {
                        divisors += counts[divisorPair];
                    }
                }
            }

            i++;
        }

        nonDivisors[current] = N - divisors;
    }

    console.log(nonDivisors);
}

Code: 16:47:13 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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        const current = numbers[i];

        let divisors = 0;
        let j = 0;
        
        while (j * j <= current) {
            if (current % j === 0) {
                if (counts[j]) {
                    divisors += counts[j];
                }

                const divisorPair = n/j;
                if (divisorPair !== i) {
                    if (counts[divisorPair]) {
                        divisors += counts[divisorPair];
                    }
                }
            }

            i++;
        }

        nonDivisors[current] = N - divisors;
    }

    console.log(nonDivisors);
}

Code: 16:47:26 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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        const current = numbers[i];

        let divisors = 0;
        let j = 0;
        
        while (j * j <= current) {
            if (current % j === 0) {
                if (counts[j]) {
                    divisors += counts[j];
                }

                const divisorPair = n/j;
                if (divisorPair !== j) {
                    if (counts[divisorPair]) {
                        divisors += counts[divisorPair];
                    }
                }
            }

            j++;
        }

        nonDivisors[current] = N - divisors;
    }

    console.log(nonDivisors);
}

The submission is being evaluated.

Code: 16:47:42 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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        const current = numbers[i];

        let divisors = 0;
        let j = 0;
        
        while (j * j <= current) {
            if (current % j === 0) {
                if (counts[j]) {
                    divisors += counts[j];
                }

                const divisorPair = /j;
                if (divisorPair !== j) {
                    if (counts[divisorPair]) {
                        divisors += counts[divisorPair];
                    }
                }
            }

            j++;
        }

        nonDivisors[current] = N - divisors;
    }

    console.log(nonDivisors);
}

Code: 16:47:56 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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        const current = numbers[i];

        let divisors = 0;
        let j = 0;
        
        while (j * j <= current) {
            if (current % j === 0) {
                if (counts[j]) {
                    divisors += counts[j];
                }

                const divisorPair = current/j;
                if (divisorPair !== j) {
                    if (counts[divisorPair]) {
                        divisors += counts[divisorPair];
                    }
                }
            }

            j++;
        }

        nonDivisors[current] = N - divisors;
    }

    console.log(nonDivisors);
}

Code: 16:47:57 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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        const current = numbers[i];

        let divisors = 0;
        let j = 0;
        
        while (j * j <= current) {
            if (current % j === 0) {
                if (counts[j]) {
                    divisors += counts[j];
                }

                const divisorPair = current/j;
                if (divisorPair !== j) {
                    if (counts[divisorPair]) {
                        divisors += counts[divisorPair];
                    }
                }
            }

            j++;
        }

        nonDivisors[current] = N - divisors;
    }

    console.log(nonDivisors);
}

The submission is being evaluated.

Code: 16:48: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 37 38 39 40 41 42 43 44 45 46

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        const current = numbers[i];

        let divisors = 0;
        let j = 0;
        
        while (j * j <= current) {
            if (current % j === 0) {
                if (counts[j]) {
                    divisors += counts[j];
                }

                const divisorPair = current/j;
                if (divisorPair !== j) {
                    if (counts[divisorPair]) {
                        divisors += counts[divisorPair];
                    }
                }
            }

            j++;
        }

        nonDivisors[current] = N - divisors;
    }

    for (let i = 0; )
}

Code: 16:48: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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        const current = numbers[i];

        let divisors = 0;
        let j = 0;
        
        while (j * j <= current) {
            if (current % j === 0) {
                if (counts[j]) {
                    divisors += counts[j];
                }

                const divisorPair = current/j;
                if (divisorPair !== j) {
                    if (counts[divisorPair]) {
                        divisors += counts[divisorPair];
                    }
                }
            }

            j++;
        }

        nonDivisors[current] = N - divisors;
    }

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

Code: 16:49:02 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        const current = numbers[i];

        let divisors = 0;
        let j = 0;
        
        while (j * j <= current) {
            if (current % j === 0) {
                if (counts[j]) {
                    divisors += counts[j];
                }

                const divisorPair = current/j;
                if (divisorPair !== j) {
                    if (counts[divisorPair]) {
                        divisors += counts[divisorPair];
                    }
                }
            }

            j++;
        }

        nonDivisors[current] = N - divisors;
    }

    const result = [];
    for (let i = 0; i < N; i++) {

    }
}

Code: 16:49:27 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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    console.log(counts);
    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        const current = numbers[i];

        let divisors = 0;
        let j = 0;
        
        while (j * j <= current) {
            if (current % j === 0) {
                if (counts[j]) {
                    divisors += counts[j];
                }

                const divisorPair = current/j;
                if (divisorPair !== j) {
                    if (counts[divisorPair]) {
                        divisors += counts[divisorPair];
                    }
                }
            }

            j++;
        }

        nonDivisors[current] = N - divisors;
    }

    const result = [];
    for (let i = 0; i < N; i++) {
        result.push(nonDivisors[A[i]]);
    }

    return result;
}

The submission is being evaluated.

Code: 16:49:32 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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        const current = numbers[i];

        let divisors = 0;
        let j = 0;
        
        while (j * j <= current) {
            if (current % j === 0) {
                if (counts[j]) {
                    divisors += counts[j];
                }

                const divisorPair = current/j;
                if (divisorPair !== j) {
                    if (counts[divisorPair]) {
                        divisors += counts[divisorPair];
                    }
                }
            }

            j++;
        }

        nonDivisors[current] = N - divisors;
    }

    const result = [];
    for (let i = 0; i < N; i++) {
        result.push(nonDivisors[A[i]]);
    }

    return result;
}

Code: 16:49:34 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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        const current = numbers[i];

        let divisors = 0;
        let j = 0;
        
        while (j * j <= current) {
            if (current % j === 0) {
                if (counts[j]) {
                    divisors += counts[j];
                }

                const divisorPair = current/j;
                if (divisorPair !== j) {
                    if (counts[divisorPair]) {
                        divisors += counts[divisorPair];
                    }
                }
            }

            j++;
        }

        nonDivisors[current] = N - divisors;
    }

    const result = [];
    for (let i = 0; i < N; i++) {
        result.push(nonDivisors[A[i]]);
    }

    return result;
}

The submission is being evaluated.

Code: 16:49:42 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

// 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        const current = numbers[i];

        let divisors = 0;
        let j = 0;
        
        while (j * j <= current) {
            if (current % j === 0) {
                if (counts[j]) {
                    divisors += counts[j];
                }

                const divisorPair = current/j;
                if (divisorPair !== j) {
                    if (counts[divisorPair]) {
                        divisors += counts[divisorPair];
                    }
                }
            }

            j++;
        }

        nonDivisors[current] = N - divisors;
    }

    const result = [];
    for (let i = 0; i < N; i++) {
        result.push(nonDivisors[A[i]]);
    }

    return result;
}

The submission is being evaluated.

Code: 16:49:45 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 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 counts = {};

    for (let i = 0; i < N; i++) {
        if (counts[A[i]]) {
            counts[A[i]]++;
        } else {
            counts[A[i]] = 1;
        }
    }

    const numbers = Object.keys(counts);
    const nonDivisors = {};
    for (let i = 0; i < numbers.length; i++) {
        const current = numbers[i];

        let divisors = 0;
        let j = 0;
        
        while (j * j <= current) {
            if (current % j === 0) {
                if (counts[j]) {
                    divisors += counts[j];
                }

                const divisorPair = current/j;
                if (divisorPair !== j) {
                    if (counts[divisorPair]) {
                        divisors += counts[divisorPair];
                    }
                }
            }

            j++;
        }

        nonDivisors[current] = N - divisors;
    }

    const result = [];
    for (let i = 0; i < N; i++) {
        result.push(nonDivisors[A[i]]);
    }

    return result;
}

The submission is being evaluated.