Test results - Codility

Code: 08:48:49 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: 08:48:53 UTC, java, 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 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89

// 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) {

        int[] result = new int[P.length];
        // 0으로 초기화
        int[] primeArray = new int[N + 1];

        int[] addedList = new int[N + 1];


        //0 = 소수
        //2이상 = 노소수

        System.out.println(primeArray[3]);

        primeArray[0] = 1;
        primeArray[1] = 1;
        int i = 2;
        //소수 구하기
        while (i * i <= N) {
//            System.out.println("i : " + i);
            if (primeArray[i] == 0) {
                int k = i * i;
                while (k <= N) {
                    if (primeArray[k] == 0) {
                        primeArray[k] = i;
                    }
                    k += i;
                }
//                System.out.println(i);
            }
            i++;
        }

        //1 ~ 100
        // 4 / 2 == prime ==0
        //

        // 나누는 수가 소수이고 나눈수도 소수일경우
        i = 2;
        while (i * i <= N) {
            if (primeArray[i] == 0) {
                int k = i * i;
                //primeArray[i] 는 무조건 소수일꺼고
                // 소수들은 subPrime이 될 수 없음
                while (k <= N) {
                    if (primeArray[k / i] == 0) {
                        primeArray[k] = -1;
                    }
                    k += i;
                }
            }
            i++;
        }

//        System.out.println("index = " + k + " isPrime = " + primeArray[k]);
        //갯수구하기
//        for (int a = 0; a < P.length; a++) {
//            int count = 0;
//            for (int k = P[a]; k <= Q[a]; k++) {
//                if(primeArray[k] == -1){
//                    count ++;
//                }
//            }
//            result[a] = count;
//        }

        int count = 0;
        for (int a = 2; a < N; a++) {
            if(primeArray[a] == -1){
                count++;
            }
            addedList[a] = count;
        }

        for(int k = 0; k < result.length; k++) {
            result[k] = addedList[Q[k]] - addedList[P[k] - 1];
            System.out.println("index = " + k + " isPrime = " + result[k]);
        }

        return result;
    }
}

Analysis

▶

example
example test

✘

WRONG ANSWER
got [0, 4, 0] expected [10, 4, 0]

Code: 08:48:57 UTC, java, 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 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89

// 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) {

        int[] result = new int[P.length];
        // 0으로 초기화
        int[] primeArray = new int[N + 1];

        int[] addedList = new int[N + 1];


        //0 = 소수
        //2이상 = 노소수

        System.out.println(primeArray[3]);

        primeArray[0] = 1;
        primeArray[1] = 1;
        int i = 2;
        //소수 구하기
        while (i * i <= N) {
//            System.out.println("i : " + i);
            if (primeArray[i] == 0) {
                int k = i * i;
                while (k <= N) {
                    if (primeArray[k] == 0) {
                        primeArray[k] = i;
                    }
                    k += i;
                }
//                System.out.println(i);
            }
            i++;
        }

        //1 ~ 100
        // 4 / 2 == prime ==0
        //

        // 나누는 수가 소수이고 나눈수도 소수일경우
        i = 2;
        while (i * i <= N) {
            if (primeArray[i] == 0) {
                int k = i * i;
                //primeArray[i] 는 무조건 소수일꺼고
                // 소수들은 subPrime이 될 수 없음
                while (k <= N) {
                    if (primeArray[k / i] == 0) {
                        primeArray[k] = -1;
                    }
                    k += i;
                }
            }
            i++;
        }

//        System.out.println("index = " + k + " isPrime = " + primeArray[k]);
        //갯수구하기
//        for (int a = 0; a < P.length; a++) {
//            int count = 0;
//            for (int k = P[a]; k <= Q[a]; k++) {
//                if(primeArray[k] == -1){
//                    count ++;
//                }
//            }
//            result[a] = count;
//        }

        int count = 0;
        for (int a = 2; a < N; a++) {
            if(primeArray[a] == -1){
                count++;
            }
            addedList[a] = count;
        }

        for(int k = 0; k < result.length; k++) {
            result[k] = addedList[Q[k]] - addedList[P[k] - 1];
            // System.out.println("index = " + k + " isPrime = " + result[k]);
        }

        return result;
    }
}

Analysis

▶

example
example test

✘

WRONG ANSWER
got [0, 4, 0] expected [10, 4, 0]

Code: 08:49:54 UTC, java, 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 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89

// 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) {

        int[] result = new int[P.length];
        // 0으로 초기화
        int[] primeArray = new int[N + 1];

        int[] addedList = new int[N + 1];


        //0 = 소수
        //2이상 = 노소수

        // System.out.println(primeArray[3]);

        primeArray[0] = 1;
        primeArray[1] = 1;
        int i = 2;
        //소수 구하기
        while (i * i <= N) {
//            System.out.println("i : " + i);
            if (primeArray[i] == 0) {
                int k = i * i;
                while (k <= N) {
                    if (primeArray[k] == 0) {
                        primeArray[k] = i;
                    }
                    k += i;
                }
//                System.out.println(i);
            }
            i++;
        }

        //1 ~ 100
        // 4 / 2 == prime ==0
        //

        // 나누는 수가 소수이고 나눈수도 소수일경우
        i = 2;
        while (i * i <= N) {
            if (primeArray[i] == 0) {
                int k = i * i;
                //primeArray[i] 는 무조건 소수일꺼고
                // 소수들은 subPrime이 될 수 없음
                while (k <= N) {
                    if (primeArray[k / i] == 0) {
                        primeArray[k] = -1;
                    }
                    k += i;
                }
            }
            i++;
        }

//        System.out.println("index = " + k + " isPrime = " + primeArray[k]);
        //갯수구하기
//        for (int a = 0; a < P.length; a++) {
//            int count = 0;
//            for (int k = P[a]; k <= Q[a]; k++) {
//                if(primeArray[k] == -1){
//                    count ++;
//                }
//            }
//            result[a] = count;
//        }

        int count = 0;
        for (int a = 2; a < N; a++) {
            if(primeArray[a] == -1){
                count++;
            }
            addedList[a] = count;
        }

        for(int k = 0; k < result.length; k++) {
            result[k] = addedList[Q[k]] - addedList[P[k] - 1];
            // System.out.println("index = " + k + " isPrime = " + result[k]);
        }

        return result;
    }
}

Code: 08:49:55 UTC, java, 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 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89

// 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) {

        int[] result = new int[P.length];
        // 0으로 초기화
        int[] primeArray = new int[N + 1];

        int[] addedList = new int[N + 1];


        //0 = 소수
        //2이상 = 노소수

        // System.out.println(primeArray[3]);

        primeArray[0] = 1;
        primeArray[1] = 1;
        int i = 2;
        //소수 구하기
        while (i * i <= N) {
//            System.out.println("i : " + i);
            if (primeArray[i] == 0) {
                int k = i * i;
                while (k <= N) {
                    if (primeArray[k] == 0) {
                        primeArray[k] = i;
                    }
                    k += i;
                }
//                System.out.println(i);
            }
            i++;
        }

        //1 ~ 100
        // 4 / 2 == prime ==0
        //

        // 나누는 수가 소수이고 나눈수도 소수일경우
        i = 2;
        while (i * i <= N) {
            if (primeArray[i] == 0) {
                int k = i * i;
                //primeArray[i] 는 무조건 소수일꺼고
                // 소수들은 subPrime이 될 수 없음
                while (k <= N) {
                    if (primeArray[k / i] == 0) {
                        primeArray[k] = -1;
                    }
                    k += i;
                }
            }
            i++;
        }

//        System.out.println("index = " + k + " isPrime = " + primeArray[k]);
        //갯수구하기
//        for (int a = 0; a < P.length; a++) {
//            int count = 0;
//            for (int k = P[a]; k <= Q[a]; k++) {
//                if(primeArray[k] == -1){
//                    count ++;
//                }
//            }
//            result[a] = count;
//        }

        int count = 0;
        for (int a = 2; a < N; a++) {
            if(primeArray[a] == -1){
                count++;
            }
            addedList[a] = count;
        }

        for(int k = 0; k < result.length; k++) {
            result[k] = addedList[Q[k]] - addedList[P[k] - 1];
            // System.out.println("index = " + k + " isPrime = " + result[k]);
        }

        return result;
    }
}

Analysis

▶

example
example test

✘

WRONG ANSWER
got [0, 4, 0] expected [10, 4, 0]

Code: 08:50:20 UTC, java, 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 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89

// 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) {

        int[] result = new int[P.length];
        // 0으로 초기화
        int[] primeArray = new int[N + 1];

        int[] addedList = new int[N + 1];


        //0 = 소수
        //2이상 = 노소수

        // System.out.println(primeArray[3]);

        primeArray[0] = 1;
        primeArray[1] = 1;
        int i = 2;
        //소수 구하기
        while (i * i <= N) {
//            System.out.println("i : " + i);
            if (primeArray[i] == 0) {
                int k = i * i;
                while (k <= N) {
                    if (primeArray[k] == 0) {
                        primeArray[k] = i;
                    }
                    k += i;
                }
//                System.out.println(i);
            }
            i++;
        }

        //1 ~ 100
        // 4 / 2 == prime ==0
        //

        // 나누는 수가 소수이고 나눈수도 소수일경우
        i = 2;
        while (i * i <= N) {
            if (primeArray[i] == 0) {
                int k = i * i;
                //primeArray[i] 는 무조건 소수일꺼고
                // 소수들은 subPrime이 될 수 없음
                while (k <= N) {
                    if (primeArray[k / i] == 0) {
                        primeArray[k] = -1;
                    }
                    k += i;
                }
            }
            i++;
        }

//        System.out.println("index = " + k + " isPrime = " + primeArray[k]);
        //갯수구하기
//        for (int a = 0; a < P.length; a++) {
//            int count = 0;
//            for (int k = P[a]; k <= Q[a]; k++) {
//                if(primeArray[k] == -1){
//                    count ++;
//                }
//            }
//            result[a] = count;
//        }

        int count = 0;
        for (int a = 2; a < N; a++) {
            if(primeArray[a] == -1){
                count++;
            }
            addedList[a] = count;
        }

        for(int k = 0; k < result.length; k++) {
            result[k] = addedList[Q[k]] - addedList[P[k] - 1];
            // System.out.println("index = " + k + " isPrime = " + result[k]);
        }

        return result;
    }
}

Analysis

▶

example
example test

✘

WRONG ANSWER
got [0, 4, 0] expected [10, 4, 0]

Code: 08:50:49 UTC, java, 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 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97

// 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) {

        int[] result = new int[P.length];
        //false로 초기화


        //소수 구하는 법
        boolean[] isNotPrime = new boolean[N + 1];
        // 0으로 초기화
        int[] primeArray = new int[N + 1];
        int[] addedList = new int[N + 1];

        //0 = 소수
        //1 =  노소수

//        System.out.println(primeArray[3]);

        primeArray[0] = 1;
        primeArray[1] = 1;
        int i = 2;
        //소수 구하기
        while (i * i <= N) {
//            System.out.println("i : " + i);
            if (primeArray[i] == 0) {
                int k = i * i;
                while (k <= N) {
                    if (primeArray[k] == 0) {
                        primeArray[k] = i;
                    }
                    k += i;
                }
//                System.out.println(i);
            }
            i++;
        }

        //1 ~ 100
        // 4 / 2 == prime ==0
        //

        // 나누는 수가 소수이고 나눈수도 소수일경우
        i = 2;
        while (i * i <= N) {
            if (primeArray[i] == 0) {
                int k = i * i;
                //primeArray[i] 는 무조건 소수일꺼고
                // 소수들은 subPrime이 될 수 없음
                while (k <= N) {
                    if (primeArray[k / i] == 0) {
                        primeArray[k] = -1;
                    }
                    k += i;
                }
            }
            i++;
        }



//        System.out.println("index = " + k + " isPrime = " + primeArray[k]);

//        for (int a = 0; a < P.length; a++) {
//            int count = 0;
//            for (int k = P[a]; k <= Q[a]; k++) {
//                if(primeArray[k] == -1){
//                    count ++;
//                }
//            }
//            result[a] = count;
//        }

        int count = 0;
        for (int a = 2; a <= N; a++) {
            if(primeArray[a] == -1){
                count++;
            }
//            System.out.println("index = " + a + " count = " + count);
            addedList[a] = count;
        }

        for(int k = 0; k < result.length; k++) {
            result[k] = addedList[Q[k]] - addedList[P[k]-1 ];
            System.out.println("index = " + k + " isPrime = " + result[k]);
//            System.out.println("Q[k] = " + Q[k] + " P[k] = " + P[k]);
//            System.out.println("addedList[Q[k]] = " + addedList[Q[k]] + " addedList[P[k] = " + addedList[P[k]]);
        }

        return result;
    }
}

Code: 08:50:49 UTC, java, 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 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97

// 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) {

        int[] result = new int[P.length];
        //false로 초기화


        //소수 구하는 법
        boolean[] isNotPrime = new boolean[N + 1];
        // 0으로 초기화
        int[] primeArray = new int[N + 1];
        int[] addedList = new int[N + 1];

        //0 = 소수
        //1 =  노소수

//        System.out.println(primeArray[3]);

        primeArray[0] = 1;
        primeArray[1] = 1;
        int i = 2;
        //소수 구하기
        while (i * i <= N) {
//            System.out.println("i : " + i);
            if (primeArray[i] == 0) {
                int k = i * i;
                while (k <= N) {
                    if (primeArray[k] == 0) {
                        primeArray[k] = i;
                    }
                    k += i;
                }
//                System.out.println(i);
            }
            i++;
        }

        //1 ~ 100
        // 4 / 2 == prime ==0
        //

        // 나누는 수가 소수이고 나눈수도 소수일경우
        i = 2;
        while (i * i <= N) {
            if (primeArray[i] == 0) {
                int k = i * i;
                //primeArray[i] 는 무조건 소수일꺼고
                // 소수들은 subPrime이 될 수 없음
                while (k <= N) {
                    if (primeArray[k / i] == 0) {
                        primeArray[k] = -1;
                    }
                    k += i;
                }
            }
            i++;
        }



//        System.out.println("index = " + k + " isPrime = " + primeArray[k]);

//        for (int a = 0; a < P.length; a++) {
//            int count = 0;
//            for (int k = P[a]; k <= Q[a]; k++) {
//                if(primeArray[k] == -1){
//                    count ++;
//                }
//            }
//            result[a] = count;
//        }

        int count = 0;
        for (int a = 2; a <= N; a++) {
            if(primeArray[a] == -1){
                count++;
            }
//            System.out.println("index = " + a + " count = " + count);
            addedList[a] = count;
        }

        for(int k = 0; k < result.length; k++) {
            result[k] = addedList[Q[k]] - addedList[P[k]-1 ];
            System.out.println("index = " + k + " isPrime = " + result[k]);
//            System.out.println("Q[k] = " + Q[k] + " P[k] = " + P[k]);
//            System.out.println("addedList[Q[k]] = " + addedList[Q[k]] + " addedList[P[k] = " + addedList[P[k]]);
        }

        return result;
    }
}

Analysis

▶

example
example test

✔

OK

Code: 08:50:57 UTC, java, 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 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97

// 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) {

        int[] result = new int[P.length];
        //false로 초기화


        //소수 구하는 법
        boolean[] isNotPrime = new boolean[N + 1];
        // 0으로 초기화
        int[] primeArray = new int[N + 1];
        int[] addedList = new int[N + 1];

        //0 = 소수
        //1 =  노소수

//        System.out.println(primeArray[3]);

        primeArray[0] = 1;
        primeArray[1] = 1;
        int i = 2;
        //소수 구하기
        while (i * i <= N) {
//            System.out.println("i : " + i);
            if (primeArray[i] == 0) {
                int k = i * i;
                while (k <= N) {
                    if (primeArray[k] == 0) {
                        primeArray[k] = i;
                    }
                    k += i;
                }
//                System.out.println(i);
            }
            i++;
        }

        //1 ~ 100
        // 4 / 2 == prime ==0
        //

        // 나누는 수가 소수이고 나눈수도 소수일경우
        i = 2;
        while (i * i <= N) {
            if (primeArray[i] == 0) {
                int k = i * i;
                //primeArray[i] 는 무조건 소수일꺼고
                // 소수들은 subPrime이 될 수 없음
                while (k <= N) {
                    if (primeArray[k / i] == 0) {
                        primeArray[k] = -1;
                    }
                    k += i;
                }
            }
            i++;
        }



//        System.out.println("index = " + k + " isPrime = " + primeArray[k]);

//        for (int a = 0; a < P.length; a++) {
//            int count = 0;
//            for (int k = P[a]; k <= Q[a]; k++) {
//                if(primeArray[k] == -1){
//                    count ++;
//                }
//            }
//            result[a] = count;
//        }

        int count = 0;
        for (int a = 2; a <= N; a++) {
            if(primeArray[a] == -1){
                count++;
            }
//            System.out.println("index = " + a + " count = " + count);
            addedList[a] = count;
        }

        for(int k = 0; k < result.length; k++) {
            result[k] = addedList[Q[k]] - addedList[P[k]-1 ];
            // System.out.println("index = " + k + " isPrime = " + result[k]);
//            System.out.println("Q[k] = " + Q[k] + " P[k] = " + P[k]);
//            System.out.println("addedList[Q[k]] = " + addedList[Q[k]] + " addedList[P[k] = " + addedList[P[k]]);
        }

        return result;
    }
}

Analysis

▶

example
example test

✔

OK

Code: 08:51:02 UTC, java, 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 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97

// 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) {

        int[] result = new int[P.length];
        //false로 초기화


        //소수 구하는 법
        boolean[] isNotPrime = new boolean[N + 1];
        // 0으로 초기화
        int[] primeArray = new int[N + 1];
        int[] addedList = new int[N + 1];

        //0 = 소수
        //1 =  노소수

//        System.out.println(primeArray[3]);

        primeArray[0] = 1;
        primeArray[1] = 1;
        int i = 2;
        //소수 구하기
        while (i * i <= N) {
//            System.out.println("i : " + i);
            if (primeArray[i] == 0) {
                int k = i * i;
                while (k <= N) {
                    if (primeArray[k] == 0) {
                        primeArray[k] = i;
                    }
                    k += i;
                }
//                System.out.println(i);
            }
            i++;
        }

        //1 ~ 100
        // 4 / 2 == prime ==0
        //

        // 나누는 수가 소수이고 나눈수도 소수일경우
        i = 2;
        while (i * i <= N) {
            if (primeArray[i] == 0) {
                int k = i * i;
                //primeArray[i] 는 무조건 소수일꺼고
                // 소수들은 subPrime이 될 수 없음
                while (k <= N) {
                    if (primeArray[k / i] == 0) {
                        primeArray[k] = -1;
                    }
                    k += i;
                }
            }
            i++;
        }



//        System.out.println("index = " + k + " isPrime = " + primeArray[k]);

//        for (int a = 0; a < P.length; a++) {
//            int count = 0;
//            for (int k = P[a]; k <= Q[a]; k++) {
//                if(primeArray[k] == -1){
//                    count ++;
//                }
//            }
//            result[a] = count;
//        }

        int count = 0;
        for (int a = 2; a <= N; a++) {
            if(primeArray[a] == -1){
                count++;
            }
//            System.out.println("index = " + a + " count = " + count);
            addedList[a] = count;
        }

        for(int k = 0; k < result.length; k++) {
            result[k] = addedList[Q[k]] - addedList[P[k]-1 ];
            // System.out.println("index = " + k + " isPrime = " + result[k]);
//            System.out.println("Q[k] = " + Q[k] + " P[k] = " + P[k]);
//            System.out.println("addedList[Q[k]] = " + addedList[Q[k]] + " addedList[P[k] = " + addedList[P[k]]);
        }

        return result;
    }
}

Analysis

▶

example
example test

✔

OK

Code: 08:51:06 UTC, java, 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 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97

// 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) {

        int[] result = new int[P.length];
        //false로 초기화


        //소수 구하는 법
        boolean[] isNotPrime = new boolean[N + 1];
        // 0으로 초기화
        int[] primeArray = new int[N + 1];
        int[] addedList = new int[N + 1];

        //0 = 소수
        //1 =  노소수

//        System.out.println(primeArray[3]);

        primeArray[0] = 1;
        primeArray[1] = 1;
        int i = 2;
        //소수 구하기
        while (i * i <= N) {
//            System.out.println("i : " + i);
            if (primeArray[i] == 0) {
                int k = i * i;
                while (k <= N) {
                    if (primeArray[k] == 0) {
                        primeArray[k] = i;
                    }
                    k += i;
                }
//                System.out.println(i);
            }
            i++;
        }

        //1 ~ 100
        // 4 / 2 == prime ==0
        //

        // 나누는 수가 소수이고 나눈수도 소수일경우
        i = 2;
        while (i * i <= N) {
            if (primeArray[i] == 0) {
                int k = i * i;
                //primeArray[i] 는 무조건 소수일꺼고
                // 소수들은 subPrime이 될 수 없음
                while (k <= N) {
                    if (primeArray[k / i] == 0) {
                        primeArray[k] = -1;
                    }
                    k += i;
                }
            }
            i++;
        }



//        System.out.println("index = " + k + " isPrime = " + primeArray[k]);

//        for (int a = 0; a < P.length; a++) {
//            int count = 0;
//            for (int k = P[a]; k <= Q[a]; k++) {
//                if(primeArray[k] == -1){
//                    count ++;
//                }
//            }
//            result[a] = count;
//        }

        int count = 0;
        for (int a = 2; a <= N; a++) {
            if(primeArray[a] == -1){
                count++;
            }
//            System.out.println("index = " + a + " count = " + count);
            addedList[a] = count;
        }

        for(int k = 0; k < result.length; k++) {
            result[k] = addedList[Q[k]] - addedList[P[k]-1 ];
            // System.out.println("index = " + k + " isPrime = " + result[k]);
//            System.out.println("Q[k] = " + Q[k] + " P[k] = " + P[k]);
//            System.out.println("addedList[Q[k]] = " + addedList[Q[k]] + " addedList[P[k] = " + addedList[P[k]]);
        }

        return result;
    }
}

Analysis summary

The solution obtained perfect score.

Analysis

Detected time complexity:

O(N * log(log(N)) + M)

▶

example
example test

✔

OK

▶

extreme_one
small N = 1

✔

OK

▶

extreme_four
small N = 4

✔

OK

▶

small_functional
small functional

✔

OK

▶

small_random
small random, length = ~40

✔

OK

▶

medium_random
small random, length = ~300

✔

OK

▶

large_small_slices
large with very small slices, length = ~30,000

✔

OK

▶

large_random1
large random, length = ~30,000

✔

OK

▶

large_random2
large random, length = ~30,000

✔

OK

▶

extreme_large
all max ranges

✔

OK