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

55%

Correctness

100%

Performance

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:

class Solution { public int[] solution(int[] 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 Java 21

Time spent on task 18 minutes

Notes

not defined yet

Code: 06:10: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) {
        // Implement your solution here
    }
}

Code: 06:10:22 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        // Implement your solution here
    }
}

Code: 06:13:21 UTC, java, autosave

show code in pop-up

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

// 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        for
        // Implement your solution here
    }
}

Code: 06:13:32 UTC, java, autosave

show code in pop-up

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

// 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        for(int i=0; i<A.lengthi; i++{
            
        })
        // Implement your solution here
    }
}

Code: 06:14:02 UTC, java, 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 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        for(int i=0; i<A.length; i++{

            for(int j=1; j*j<=i; j++){
                if(j*j==i )
            }

        })
        // Implement your solution here
    }
}

Code: 06:14:13 UTC, java, 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

// 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        for(int i=0; i<A.length; i++{

            for(int j=1; j*j<=i; j++){
                if(j*j==i || i%j==0){
                    
                }
            }

        })
        // Implement your solution here
    }
}

Code: 06:14:43 UTC, java, 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 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++{

            for(int j=1; j*j<=i; j++){
                if(j*j==i || i%j==0){
                    list.add(j);
                }
            }

        })
        // Implement your solution here
    }
}

Code: 06:15:01 UTC, java, 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 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++{

            for(int j=1; j*j<=i; j++){
                if(j*j==i || i%j==0){
                    set.put()
                }
            }

        })
        // Implement your solution here
    }
}

Code: 06:15:18 UTC, java, 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 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++{

            for(int j=1; j*j<=i; j++){
                if(j*j==i || i%j==0){
                    list.add(j);
                }
            }

        })
        // Implement your solution here
    }
}

Code: 06:15:28 UTC, java, 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 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++{

            for(int j=1; j*j<=i; j++){
                if(j*j==i || i%j==0){
                    list.add(j);
                    
                }
            }

        })
        // Implement your solution here
    }
}

Code: 06:15:39 UTC, java, 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

// 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++{

            for(int j=1; j*j<=i; j++){
                if(j*j==i) {list.add(j)};
                else if( || i%j==0){
                    )
                    
                }
            }

        })
        // Implement your solution here
    }
}

Code: 06:16:01 UTC, java, 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

// 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++{

            for(int j=1; j*j<=i; j++){
                if(j*j==i) {list.add(j)};
                else if(i%j==0){list.add(j); list.add(i/j);}
                    )
                    
                }
            }

        })
        // Implement your solution here
    }
}

Code: 06:16:14 UTC, java, 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 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            for(int j=1; j*j<=i; j++){
                if(j*j==i) {list.add(j)};
                else if(i%j==0){list.add(j); list.add(i/j);}
                    )
                    
                }
            }

        })
        // Implement your solution here
    }
}

Code: 06:16:36 UTC, java, 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

// 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            for(int j=1; j*j<=i; j++){
                if(j*j==i) {
                    list.add(j)
                };
                else if(i%j==0){
                    list.add(j); list.add(i/j);
                }
                
                    
                }
            }

        })
        // Implement your solution here
    }
}

Code: 06:16:47 UTC, java, 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 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            for(int j=1; j*j<=i; j++){
                if(j*j==i) {
                    list.add(j);
                }
                else if(i%j==0){
                    list.add(j); 
                    list.add(i/j);
                }
                
                    
                }
            }

        })
        // Implement your solution here
    }
}

Code: 06:17:11 UTC, java, 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 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            for(int j=1; j*j<=i; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(i%j==0){
                    list.add(j); 
                    list.add(i/j);
                }
                
                    
                }
            }

        })
        // Implement your solution here
    }
}

Code: 06:17:23 UTC, java, 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 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            for(int j=1; j*j<=i; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }
                
                    
                }
            }

        })
        // Implement your solution here
    }
}

Code: 06:17:36 UTC, java, 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

// 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            for(int j=1; j*j<=i; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }
                    
                }
            }

        })
        // Implement your solution here
    }
}

Code: 06:17:53 UTC, java, 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 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            for(int j=1; j*j<=i; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }   
            }
            }

        })
        // Implement your solution here
    }
}

Code: 06:18:23 UTC, java, autosave

show code in pop-up

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

// you can 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            for(int j=1; j*j<=i; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }   
            }
            for(int z=0; z<A.length; z++){
                if(A[z].c)
            }
        }

        })
        // Implement your solution here
    }
}

Code: 06:18:34 UTC, java, autosave

show code in pop-up

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

// you can 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            for(int j=1; j*j<=i; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }   
            }
            for(int z=0; z<A.length; z++){
                if(list.contains(A[z])
            }
        }

        })
        // Implement your solution here
    }
}

Code: 06:18:44 UTC, java, 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 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            for(int j=1; j*j<=i; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }   
            }
            for(int z=0; z<A.length; z++){
                if(list.contains(A[z])){
                    
                }
            }
        }

        })
        // Implement your solution here
    }
}

Code: 06:19:02 UTC, java, 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 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            int cnt =0;
            for(int j=1; j*j<=i; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }   
            }
            for(int z=0; z<A.length; z++){
                if(list.contains(A[z])){
                    cnt++;
                }
            }
        }

        })
        // Implement your solution here
    }
}

Code: 06:19:15 UTC, java, 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 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            int cnt =0;
            for(int j=1; j*j<=i; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }   
            }
            for(int z=0; z<A.length; z++){
                if(!list.contains(A[z])){
                    cnt++;
                }
            }
        }

        })
        // Implement your solution here
    }
}

Code: 06:19:45 UTC, java, 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 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        Array<Int
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            int cnt =0;
            for(int j=1; j*j<=i; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }   
            }
            for(int z=0; z<A.length; z++){
                if(!list.contains(A[z])){
                    cnt++;
                }
            }

        }

        })
        // Implement your solution here
    }
}

Code: 06:20:00 UTC, java, 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 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        A
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            int cnt =0;
            for(int j=1; j*j<=i; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }   
            }
            for(int z=0; z<A.length; z++){
                if(!list.contains(A[z])){
                    cnt++;
                }
            }

        }

        })
        // Implement your solution here
    }
}

Code: 06:20:31 UTC, java, 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 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        입[] 변수 = new 타입[길이];
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            int cnt =0;
            for(int j=1; j*j<=i; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }   
            }
            for(int z=0; z<A.length; z++){
                if(!list.contains(A[z])){
                    cnt++;
                }
            }

        }

        })
        // Implement your solution here
    }
}

Code: 06:20:45 UTC, java, 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 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        int[]arr = new int[A.length]];
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            int cnt =0;
            for(int j=1; j*j<=i; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }   
            }
            for(int z=0; z<A.length; z++){
                if(!list.contains(A[z])){
                    cnt++;
                }
            }

        }

        })
        // Implement your solution here
    }
}

Code: 06:20:56 UTC, java, 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 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        int[]arr = new int[A.length];
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            int cnt =0;
            for(int j=1; j*j<=i; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }   
            }
            for(int z=0; z<A.length; z++){
                if(!list.contains(A[z])){
                    cnt++;
                }
            }

        }

        })
        // Implement your solution here
    }
}

Code: 06:21:11 UTC, java, 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 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        int[] arr = new int[A.length];
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            int cnt =0;
            for(int j=1; j*j<=i; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }   
            }
            for(int z=0; z<A.length; z++){
                if(!list.contains(A[z])){
                    cnt++;
                }
            }

        }

        })
        // Implement your solution here
    }
}

Code: 06:21:52 UTC, java, 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

// 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        int[] arr = new int[A.length];
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            int cnt =0;
            for(int j=1; j*j<=i; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }   
            }
            for(int z=0; z<A.length; z++){
                if(!list.contains(A[z])){
                    cnt++;
                }
                
            }

        }

        })
        // Implement your solution here
    }
}

Code: 06:22:08 UTC, java, 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

// 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        int[] arr = new int[A.length];
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            int cnt =0;
            for(int j=1; j*j<=i; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }   
            }
            for(int z=0; z<A.length; z++){
                if(!list.contains(A[z])){
                    cnt++;
                }
            }
            arr[i] = cnt;

        }

        })
        // Implement your solution here
    }
}

Code: 06:22:21 UTC, java, 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

// 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        int[] arr = new int[5];
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            int cnt =0;
            for(int j=1; j*j<=i; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }   
            }
            for(int z=0; z<A.length; z++){
                if(!list.contains(A[z])){
                    cnt++;
                }
            }
            arr[i] = cnt;

        }

        })
        // Implement your solution here
    }
}

Code: 06:22:36 UTC, java, verify, result: Failed

show code in pop-up

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

// you can 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        int[] arr = new int[5];
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            int cnt =0;
            for(int j=1; j*j<=i; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }   
            }
            for(int z=0; z<A.length; z++){
                if(!list.contains(A[z])){
                    cnt++;
                }
            }
            arr[i] = cnt;

        }

        })
        // Implement your solution here
    }
}

The submission is being evaluated.

Code: 06:22:51 UTC, java, 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

// 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        int[] arr = new int[5];
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            int cnt =0;
            for(int j=1; j*j<=i; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }   
            }
            for(int z=0; z<A.length; z++){
                if(!list.contains(A[z])){
                    cnt++;
                }
            }
            arr[i] = cnt;

        }

        }
        // Implement your solution here
    }
}

Code: 06:22:53 UTC, java, 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

// 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        int[] arr = new int[5];
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            int cnt =0;
            for(int j=1; j*j<=i; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }   
            }
            for(int z=0; z<A.length; z++){
                if(!list.contains(A[z])){
                    cnt++;
                }
            }
            arr[i] = cnt;

        }
        }
        // Implement your solution here
    }
}

The submission is being evaluated.

Code: 06:23:07 UTC, java, verify, result: Failed

show code in pop-up

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

// you can 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        int[] arr = new int[5];
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            int cnt =0;
            for(int j=1; j*j<=i; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }   
            }
            for(int z=0; z<A.length; z++){
                if(!list.contains(A[z])){
                    cnt++;
                }
            }
            arr[i] = cnt;

        }
        return arr;
        }
        // Implement your solution here
    }
}

The submission is being evaluated.

Code: 06:23:21 UTC, java, verify, result: Failed

show code in pop-up

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

// you can 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        int[] arr = new int[5];
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            int cnt =0;
            for(int j=1; j*j<=i; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }   
            }
            for(int z=0; z<A.length; z++){
                if(!list.contains(A[z])){
                    cnt++;
                }
            }
            arr[i] = cnt;

        }
        return arr;
        }
        // Implement your solution here
    }

The submission is being evaluated.

Code: 06:23:58 UTC, java, 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

// 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        int[] arr = new int[];
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            int cnt =0;
            for(int j=1; j*j<=i; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }   
            }
            for(int z=0; z<A.length; z++){
                if(!list.contains(A[z])){
                    cnt++;
                }
            }
            arr[i] = cnt;

        }
        return arr;
        }
        // Implement your solution here
    }

Code: 06:24:08 UTC, java, 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

// 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        int[] arr = new int[A.length];
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            int cnt =0;
            for(int j=1; j*j<=i; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }   
            }
            for(int z=0; z<A.length; z++){
                if(!list.contains(A[z])){
                    cnt++;
                }
            }
            arr[i] = cnt;

        }
        return arr;
        }
        // Implement your solution here
    }

Code: 06:24:09 UTC, java, verify, result: Failed

show code in pop-up

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

// you can 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        int[] arr = new int[A.length];
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            int cnt =0;
            for(int j=1; j*j<=i; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }   
            }
            for(int z=0; z<A.length; z++){
                if(!list.contains(A[z])){
                    cnt++;
                }
            }
            arr[i] = cnt;

        }
        return arr;
        }
        // Implement your solution here
    }

The submission is being evaluated.

Code: 06:26:33 UTC, java, 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 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        int[] arr = new int[A.length];
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            int cnt =0;
            
            for(int j=1; j*j<=i; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }   
            }
            for(int z=0; z<A.length; z++){
                if(!list.contains(A[z])){
                    cnt++;
                }
            }
            arr[i] = cnt;

        }
        return arr;
        }
        // Implement your solution here
    }

Code: 06:26:43 UTC, java, 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

// 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        int[] arr = new int[A.length];
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            int cnt =0;
            list = new ArrayList<>();
            for(int j=1; j*j<=i; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }   
            }
            for(int z=0; z<A.length; z++){
                if(!list.contains(A[z])){
                    cnt++;
                }
            }
            arr[i] = cnt;

        }
        return arr;
        }
        // Implement your solution here
    }

The submission is being evaluated.

Code: 06:27:06 UTC, java, 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 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        int[] arr = new int[A.length];
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            int cnt =0;
            list = new ArrayList<>();
            for(int j=1; j*j<=A[i; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }   
            }
            for(int z=0; z<A.length; z++){
                if(!list.contains(A[z])){
                    cnt++;
                }
            }
            arr[i] = cnt;

        }
        return arr;
        }
        // Implement your solution here
    }

Code: 06:27:09 UTC, java, 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

// 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        int[] arr = new int[A.length];
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            int cnt =0;
            list = new ArrayList<>();
            for(int j=1; j*j<=A[i]; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }   
            }
            for(int z=0; z<A.length; z++){
                if(!list.contains(A[z])){
                    cnt++;
                }
            }
            arr[i] = cnt;

        }
        return arr;
        }
        // Implement your solution here
    }

The submission is being evaluated.

Code: 06:27:16 UTC, java, 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

// 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        int[] arr = new int[A.length];
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            int cnt =0;
            list = new ArrayList<>();
            for(int j=1; j*j<=A[i]; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }   
            }
            for(int z=0; z<A.length; z++){
                if(!list.contains(A[z])){
                    cnt++;
                }
            }
            arr[i] = cnt;

        }
        return arr;
        }
        // Implement your solution here
    }

The submission is being evaluated.

Code: 06:27:19 UTC, java, final, score: 55

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 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");
import java.util.*;
class Solution {
    public int[] solution(int[] A) {
        int[] arr = new int[A.length];
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<A.length; i++){
            int cnt =0;
            list = new ArrayList<>();
            for(int j=1; j*j<=A[i]; j++){
                if(j*j==A[i]) {
                    list.add(j);
                }
                else if(A[i]%j==0){
                    list.add(j); 
                    list.add(A[i]/j);
                }   
            }
            for(int z=0; z<A.length; z++){
                if(!list.contains(A[z])){
                    cnt++;
                }
            }
            arr[i] = cnt;

        }
        return arr;
        }
        // Implement your solution here
    }

The submission is being evaluated.