Test results - Codility

Code: 14:13:09 UTC, java, autosave

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 N, int[] P, int[] Q) {
        // write your code in Java SE 8
    }
}

Code: 14:13:14 UTC, js, autosave

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(N, P, Q) {
    // write your code in JavaScript (Node.js 8.9.4)
}

Code: 14:18:26 UTC, js, autosave

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(N, P, Q) {
    
}

Code: 14:19:36 UTC, js, autosave

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(N, P, Q) {
    cons
}

Code: 14:19:47 UTC, js, autosave

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(N, P, Q) {
    const primes 
}

Code: 14:20:09 UTC, js, autosave

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(N, P, Q) {
    const primes = new Array(N).fill(true);
}

Code: 14:20:25 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10

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

function solution(N, P, Q) {
    const primes = new Array(N).fill(true);

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

Code: 14:20:41 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10

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

function solution(N, P, Q) {
    const primes = new Array(N).fill(true);

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

Code: 14:20:54 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10

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

function solution(N, P, Q) {
    const primes = new Array(N).fill(true);

    for (let i = 0; i < Math.sqrt(N); i++) {
        if ()
    }
}

Code: 14:21:07 UTC, js, autosave

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

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

function solution(N, P, Q) {
    const primes = new Array(N).fill(true);

    for (let i = 0; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            
        }
    }
}

Code: 14:21:24 UTC, js, autosave

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

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

function solution(N, P, Q) {
    const primes = new Array(N).fill(true);

    for (let i = 1; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let i = 0)
        }
    }
}

Code: 14:21:55 UTC, js, autosave

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(N, P, Q) {
    const primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 1; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let i = 0)
        }
    }
}

Code: 14:22:12 UTC, js, autosave

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(N, P, Q) {
    const primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i)
        }
    }
}

Code: 14:22:27 UTC, js, autosave

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(N, P, Q) {
    const primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; )
        }
    }
}

Code: 14:22:49 UTC, js, verify, result: Failed

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(N, P, Q) {
    const primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    console.log(primes);
}

The submission is being evaluated.

Code: 14:23:04 UTC, js, autosave

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(N, P, Q) {
    const primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

   
}

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

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(N, P, Q) {
    const primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    
}

Code: 14:23:26 UTC, js, autosave

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(N, P, Q) {
    const primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = 
}

Code: 14:23:56 UTC, js, autosave

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(N, P, Q) {
    const primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value) => {
        if (value) {
            acc.p
        }
    }, [])
}

Code: 14:24:06 UTC, js, autosave

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(N, P, Q) {
    const primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value) => {
        if (value) {
            acc.push()
        }
    }, [])
}

Code: 14:24:29 UTC, js, verify, result: Failed

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(N, P, Q) {
    const primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) {
            acc.push(index);
        }

        return acc;
    }, [])

    console.log(primes);
}

The submission is being evaluated.

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

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) {
            acc.push(index);
        }

        return acc;
    }, [])

    console.log(primes);
}

Code: 14:24:42 UTC, js, verify, result: Failed

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) {
            acc.push(index);
        }

        return acc;
    }, [])

    console.log(primes);
}

The submission is being evaluated.

Code: 14:25:12 UTC, js, autosave

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

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

function solution(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    console.log(primes);
}

Code: 14:25:22 UTC, js, autosave

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

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

function solution(N, P, Q) {
    const primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    console.log(primes);
}

Code: 14:25:33 UTC, js, autosave

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

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

function solution(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    console.log(primes);
}

Code: 14:26:04 UTC, js, autosave

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    const semiPrimes = [];

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

Code: 14:26:34 UTC, js, autosave

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    const semiPrimes = [];

    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semi
            }
        }
    }
}

Code: 14:26:57 UTC, js, autosave

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    const semiPrimes = new Map();

    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.
            }
        }
    }
}

Code: 14:27:16 UTC, js, verify, result: Failed

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    const semiPrimes = new Map();

    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.set(semiPrime);
            }
        }
    }

    console.log(semiPrimes);
}

The submission is being evaluated.

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

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    const semiPrimes = new Set();

    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.set(semiPrime);
            }
        }
    }

    console.log(semiPrimes);
}

Code: 14:27:33 UTC, js, verify, result: Failed

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    const semiPrimes = new Set();

    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }

    console.log(semiPrimes);
}

The submission is being evaluated.

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

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    console.log(primes);

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }

    console.log(semiPrimes);
}

Code: 14:28:01 UTC, js, verify, result: Failed

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    console.log(primes);

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }

    console.log(semiPrimes);
}

The submission is being evaluated.

Code: 14:28:33 UTC, js, autosave

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    console.log(primes);

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

    

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }

    console.log(semiPrimes);
}

Code: 14:28:38 UTC, js, verify, result: Failed

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    console.log(primes);

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            console.log(semiPrime);

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }

    console.log(semiPrimes);
}

The submission is being evaluated.

Code: 14:29:04 UTC, js, autosave

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    console.log(primes);

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            console.log(semiPrime);

            if (semiPrime <= N) {
                console
                semiPrimes.add(semiPrime);
            }
        }
    }

    console.log(semiPrimes);
}

Code: 14:29:09 UTC, js, verify, result: Failed

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

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

function solution(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    console.log(primes);

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                console.log(semiPrimes)
                semiPrimes.add(semiPrime);
            }
        }
    }

    console.log(semiPrimes);
}

The submission is being evaluated.

Code: 14:29:18 UTC, js, verify, result: Failed

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    console.log(primes);

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }

    console.log(semiPrimes);
}

The submission is being evaluated.

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

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    console.log(primes);

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }

    const or
}

Code: 14:30:14 UTC, js, verify, result: Failed

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    console.log(primes);

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }

    const orderedSemiPrimes = [...semiPrimes].sort((a, b) => b - a);

    console.log(orderedSemiPrimes);
}

The submission is being evaluated.

Code: 14:30:20 UTC, js, autosave

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    console.log(primes);

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }

    const orderedSemiPrimes = [...semiPrimes].sort((a, b) => a - b);

    console.log(orderedSemiPrimes);
}

Code: 14:30:20 UTC, js, verify, result: Failed

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    console.log(primes);

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }

    const orderedSemiPrimes = [...semiPrimes].sort((a, b) => a - b);

    console.log(orderedSemiPrimes);
}

The submission is being evaluated.

Code: 14:30:38 UTC, js, autosave

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }

    const orderedSemiPrimes = [...semiPrimes].sort((a, b) => a - b);
    const 
}

Code: 14:31:08 UTC, js, autosave

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

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

function solution(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }

    const orderedSemiPrimes = [...semiPrimes].sort((a, b) => a - b);
    const cumSum = [];

    fo
}

Code: 14:31:22 UTC, js, autosave

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }

    const orderedSemiPrimes = [...semiPrimes].sort((a, b) => a - b);
    const cumSum = [];

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

Code: 14:31:52 UTC, js, autosave

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }

    const orderedSemiPrimes = [...semiPrimes].sort((a, b) => a - b);
    const cumSum = [0];

    for (let i = 1; i <= N; i++) {
        cumSum.push()
    }
}

Code: 14:32:43 UTC, js, autosave

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }

    const orderedSemiPrimes = [...semiPrimes].sort((a, b) => a - b);
    const cumSum = [0];

    for (let i = 1; i <= N; i++) {
        cumSum.push(cumSum)
    }
}

Code: 14:32:57 UTC, js, autosave

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }

    const orderedSemiPrimes = [...semiPrimes].sort((a, b) => a - b);
    const cumSum = [0];

    for (let i = 0; i <= N; i++) {
        cumSum.push(cumSum[i]);

        
    }
}

Code: 14:33:08 UTC, js, autosave

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }

    const orderedSemiPrimes = [...semiPrimes].sort((a, b) => a - b);
    const cumSum = [0];

    for (let i = 0; i <= N; i++) {
        cumSum.push(cumSum[i]);

        if (orde)
    }
}

Code: 14:33:33 UTC, js, autosave

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }
    const cumSum = [0];
    for (let i = 0; i <= N; i++) {
        cumSum.push(cumSum[i]);

        if (semiPrimes.)
    }
}

Code: 14:34:04 UTC, js, autosave

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }
    const cumSum = [0];
    for (let i = 0; i <= N; i++) {
        cumSum.push(cumSum[i]);

        if (semiPrimes.has(i)) {
            cumSum[i + 1]++;
        }
    }

    console.log(cumSum);
}

Code: 14:34:05 UTC, js, verify, result: Failed

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }
    const cumSum = [0];
    for (let i = 0; i <= N; i++) {
        cumSum.push(cumSum[i]);

        if (semiPrimes.has(i)) {
            cumSum[i + 1]++;
        }
    }

    console.log(cumSum);
}

The submission is being evaluated.

Code: 14:34:31 UTC, js, autosave

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }
    const cumSum = [0];
    for (let i = 0; i <= N; i++) {
        cumSum.push(cumSum[i]);

        if (semiPrimes.has(i)) {
            cumSum[i + 1]++;
        }
    }

    const results = [];
    for (let i = 0; i < P.length; i++) {
        
    }
}

Code: 14:35:00 UTC, js, verify, result: Failed

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }
    const cumSum = [0];
    for (let i = 0; i <= N; i++) {
        cumSum.push(cumSum[i]);

        if (semiPrimes.has(i)) {
            cumSum[i + 1]++;
        }
    }

    const results = [];
    for (let i = 0; i < P.length; i++) {
        results.push(cumSum[Q[i]] - cumSum[P[i]]);
    }

    return return;
}

The submission is being evaluated.

Code: 14:35:03 UTC, js, verify, result: Failed

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }
    const cumSum = [0];
    for (let i = 0; i <= N; i++) {
        cumSum.push(cumSum[i]);

        if (semiPrimes.has(i)) {
            cumSum[i + 1]++;
        }
    }

    const results = [];
    for (let i = 0; i < P.length; i++) {
        results.push(cumSum[Q[i]] - cumSum[P[i]]);
    }

    return results;
}

The submission is being evaluated.

Code: 14:35:30 UTC, js, autosave

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }
    const cumSum = [0];
    for (let i = 0; i <= N; i++) {
        cumSum.push(cumSum[i]);

        if (semiPrimes.has(i)) {
            cumSum[i + 1]++;
        }
    }

    

    const results = [];
    for (let i = 0; i < P.length; i++) {
        results.push(cumSum[Q[i]] - cumSum[P[i]]);
    }

    return results;
}

Code: 14:35:33 UTC, js, verify, result: Failed

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }
    const cumSum = [0];
    for (let i = 0; i <= N; i++) {
        cumSum.push(cumSum[i]);

        if (semiPrimes.has(i)) {
            cumSum[i + 1]++;
        }
    }

    console.log(cumSum);

    const results = [];
    for (let i = 0; i < P.length; i++) {
        results.push(cumSum[Q[i]] - cumSum[P[i]]);
    }

    return results;
}

The submission is being evaluated.

Code: 14:37:45 UTC, js, autosave

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }
    const cumSum = [0];
    for (let i = 0; i <= N; i++) {
        cumSum.push(cumSum[i]);

        if (semiPrimes.has(i )) {
            cumSum[i + 1]++;
        }
    }

    console.log(cumSum);

    const results = [];
    for (let i = 0; i < P.length; i++) {
        results.push(cumSum[Q[i]] - cumSum[P[i]]);
    }

    return results;
}

Code: 14:37:47 UTC, js, verify, result: Failed

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }
    const cumSum = [0];
    for (let i = 0; i <= N; i++) {
        cumSum.push(cumSum[i]);

        if (semiPrimes.has(i + 1)) {
            cumSum[i + 1]++;
        }
    }

    console.log(cumSum);

    const results = [];
    for (let i = 0; i < P.length; i++) {
        results.push(cumSum[Q[i]] - cumSum[P[i]]);
    }

    return results;
}

The submission is being evaluated.

Code: 14:38:58 UTC, js, autosave

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }
    const cumSum = [0];
    for (let i = 0; i <= N; i++) {
        cumSum.push(cumSum[i]);

        if (semiPrimes.has(i + 1)) {
            cumSum[i + 1]++;
        }
    }

    console.log(cumSum);

    const results = [];
    for (let i = 0; i < P.length; i++) {
        results.push(cumSum[Q[i]] - cumSum[P[i] - 1]);
    }

    return results;
}

Code: 14:38:59 UTC, js, verify, result: Passed

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }
    const cumSum = [0];
    for (let i = 0; i <= N; i++) {
        cumSum.push(cumSum[i]);

        if (semiPrimes.has(i + 1)) {
            cumSum[i + 1]++;
        }
    }

    console.log(cumSum);

    const results = [];
    for (let i = 0; i < P.length; i++) {
        results.push(cumSum[Q[i]] - cumSum[P[i] - 1]);
    }

    return results;
}

The submission is being evaluated.

Code: 14:39:03 UTC, js, verify, result: Passed

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(N, P, Q) {
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }
    const cumSum = [0];
    for (let i = 0; i <= N; i++) {
        cumSum.push(cumSum[i]);

        if (semiPrimes.has(i + 1)) {
            cumSum[i + 1]++;
        }
    }

    const results = [];
    for (let i = 0; i < P.length; i++) {
        results.push(cumSum[Q[i]] - cumSum[P[i] - 1]);
    }

    return results;
}

The submission is being evaluated.

Code: 14:39:23 UTC, js, autosave

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(N, P, Q) {
    
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }
    const cumSum = [0];
    for (let i = 0; i <= N; i++) {
        cumSum.push(cumSum[i]);

        if (semiPrimes.has(i + 1)) {
            cumSum[i + 1]++;
        }
    }

    const results = [];
    for (let i = 0; i < P.length; i++) {
        results.push(cumSum[Q[i]] - cumSum[P[i] - 1]);
    }

    return results;
}

Code: 14:39:33 UTC, js, autosave

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(N, P, Q) {
    // Sieve of Eratosthenes
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }
    const cumSum = [0];
    for (let i = 0; i <= N; i++) {
        cumSum.push(cumSum[i]);

        if (semiPrimes.has(i + 1)) {
            cumSum[i + 1]++;
        }
    }

    const results = [];
    for (let i = 0; i < P.length; i++) {
        results.push(cumSum[Q[i]] - cumSum[P[i] - 1]);
    }

    return results;
}

Code: 14:39:51 UTC, js, autosave

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(N, P, Q) {
    // Sieve of Eratosthenes
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    // converting to list of primes
    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    // calculating semiprimes
    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }
    const cumSum = [0];
    for (let i = 0; i <= N; i++) {
        cumSum.push(cumSum[i]);

        if (semiPrimes.has(i + 1)) {
            cumSum[i + 1]++;
        }
    }

    const results = [];
    for (let i = 0; i < P.length; i++) {
        results.push(cumSum[Q[i]] - cumSum[P[i] - 1]);
    }

    return results;
}

Code: 14:40:20 UTC, js, verify, result: Passed

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(N, P, Q) {
    // Sieve of Eratosthenes
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    // converting to list of primes
    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    // calculating semiprimes
    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }

    // computing prefix sums of semiprimes
    const cumSum = [0];
    for (let i = 0; i <= N; i++) {
        cumSum.push(cumSum[i]);

        if (semiPrimes.has(i + 1)) {
            cumSum[i + 1]++;
        }
    }

    // running queries
    const results = [];
    for (let i = 0; i < P.length; i++) {
        results.push(cumSum[Q[i]] - cumSum[P[i] - 1]);
    }

    return results;
}

The submission is being evaluated.

Code: 14:40:30 UTC, js, verify, result: Passed

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(N, P, Q) {
    // Sieve of Eratosthenes
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    // converting to list of primes
    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    // calculating semiprimes
    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }

    // computing prefix sums of semiprimes
    const cumSum = [0];
    for (let i = 0; i <= N; i++) {
        cumSum.push(cumSum[i]);

        if (semiPrimes.has(i + 1)) {
            cumSum[i + 1]++;
        }
    }

    // running queries
    const results = [];
    for (let i = 0; i < P.length; i++) {
        results.push(cumSum[Q[i]] - cumSum[P[i] - 1]);
    }

    return results;
}

The submission is being evaluated.

Code: 14:40:32 UTC, js, final, score: 100

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(N, P, Q) {
    // Sieve of Eratosthenes
    let primes = new Array(N).fill(true);
    primes[0] = primes[1] = false;

    for (let i = 2; i < Math.sqrt(N); i++) {
        if (primes[i]) {
            for (let j = i + i; j <= N; j+=i) {
                primes[j] = false;
            }
        }
    }

    // converting to list of primes
    primes = primes.reduce((acc, value, index) => {
        if (value) acc.push(index);
    
        return acc;
    }, [])

    // calculating semiprimes
    const semiPrimes = new Set();
    for (let i = 0; i < primes.length; i++) {
        for (let j = 0; j < primes.length; j++) {
            const semiPrime = primes[i] * primes[j];

            if (semiPrime <= N) {
                semiPrimes.add(semiPrime);
            }
        }
    }

    // computing prefix sums of semiprimes
    const cumSum = [0];
    for (let i = 0; i <= N; i++) {
        cumSum.push(cumSum[i]);

        if (semiPrimes.has(i + 1)) {
            cumSum[i + 1]++;
        }
    }

    // running queries
    const results = [];
    for (let i = 0; i < P.length; i++) {
        results.push(cumSum[Q[i]] - cumSum[P[i] - 1]);
    }

    return results;
}

The submission is being evaluated.