Test results - Codility

Tasks Details

medium

1. DividingTheKingdom

In how many ways can you split a kingdom into two parts, so that the parts contain equal number of gold mines?

Task Score

100%

Correctness

100%

Performance

100%

An old king wants to divide his kingdom between his two sons. He is well known for his justness and wisdom, and he plans to make a good use of both of these attributes while dividing his kingdom.

The kingdom is administratively split into square boroughs that form an N × M grid. Some of the boroughs contain gold mines. The king knows that his sons do not care as much about the land as they do about gold, so he wants both parts of the kingdom to contain exactly the same number of mines. Moreover, he wants to split the kingdom with either a horizontal or a vertical line that goes along the borders of the boroughs (splitting no borough into two parts).

The goal is to count how many ways he can split the kingdom.

Write a function:

class Solution { public int solution(int N, int M, int[] X, int[] Y); }

that, given two arrays of K integers X and Y, denoting coordinates of boroughs containing the gold mines, will compute the number of fair divisions of the kingdom.

For example, given N = 5, M = 5, X = [0, 4, 2, 0] and Y = [0, 0, 1, 4], the function should return 3. The king can divide his land in three different ways shown on the picture below.

Divide horizontally in two ways or vertically in one way

Write an efficient algorithm for the following assumptions:

N and M are integers within the range [1..100,000];

K is an integer within the range [1..100,000];

each element of array X is an integer within the range [0..N-1];

each element of array Y is an integer within the range [0..M-1].

Solution

Programming language used Java 21

Time spent on task 12 minutes

Notes

not defined yet

Code: 07:07:19 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 N, int M, int[] X, int[] Y) {
        // write your code in Java SE 8
    }
}

Code: 07:09:11 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 N, int M, int[] X, int[] Y) {
        
    }
}

Code: 07:09:21 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 N, int M, int[] X, int[] Y) {
        int[] 
    }
}

Code: 07:09:52 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");

class Solution {
    public int solution(int N, int M, int[] X, int[] Y) {
        int[] hor = new int[N];
        
    }
}

Code: 07:10:02 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");

class Solution {
    public int solution(int N, int M, int[] X, int[] Y) {
        int[] hor = new int[N];
        int[] ver = new int[M];
    }
}

Code: 07:10: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

// 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 M, int[] X, int[] Y) {
        int[] hor = new int[N];
        int[] ver = new int[M];
        for(int i=0;i<X.length;i++){
            hor[X[i]]++;
            ver[Y[i]]
        }
        
    }
}

Code: 07:10: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

// 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 M, int[] X, int[] Y) {
        int[] hor = new int[N];
        int[] ver = new int[M];
        for(int i=0;i<X.length;i++){
            hor[X[i]]++;
            ver[Y[i]]++;
        }
        
    }
}

Code: 07:11:22 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

// 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 M, int[] X, int[] Y) {
        int[] hor = new int[N];
        int[] ver = new int[M];
        for(int i=0;i<X.length;i++){
            hor[X[i]]++;
            ver[Y[i]]++;
        }
        
        
        
    }
}

Code: 07:11: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

// 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 M, int[] X, int[] Y) {
        int[] hor = new int[N];
        int[] ver = new int[M];
        for(int i=0;i<X.length;i++){
            hor[X[i]]++;
            ver[Y[i]]++;
        }
        
        int horCumulated = 0;
        for(int i)
        
    }
}

Code: 07:12:16 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");

class Solution {
    public int solution(int N, int M, int[] X, int[] Y) {
        int[] hor = new int[N];
        int[] ver = new int[M];
        for(int i=0;i<X.length;i++){
            hor[X[i]]++;
            ver[Y[i]]++;
        }
        
        int horCumulated = 0;
        for(int i=0;i<N;i++){
            horCumulated+=
        }
        
    }
}

Code: 07:12:30 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");

class Solution {
    public int solution(int N, int M, int[] X, int[] Y) {
        int[] hor = new int[N];
        int[] ver = new int[M];
        for(int i=0;i<X.length;i++){
            hor[X[i]]++;
            ver[Y[i]]++;
        }
        
        int horCumulated = 0;
        for(int i=0;i<N;i++){
            horCumulated+=hor[i];
            if(horCumulated==)
        }
        
    }
}

Code: 07:12: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

// 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 M, int[] X, int[] Y) {
        int[] hor = new int[N];
        int[] ver = new int[M];
        for(int i=0;i<X.length;i++){
            hor[X[i]]++;
            ver[Y[i]]++;
        }
        
        int horCumulated = 0;
        for(int i=0;i<N;i++){
            horCumulated+=hor[i];
            if(horCumulated==X.length/2)
        }
        
    }
}

Code: 07:12: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

// 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 M, int[] X, int[] Y) {
        int[] hor = new int[N];
        int[] ver = new int[M];
        for(int i=0;i<X.length;i++){
            hor[X[i]]++;
            ver[Y[i]]++;
        }
        
        int horCumulated = 0;
        int validSplits = 0;
        for(int i=0;i<N;i++){
            horCumulated+=hor[i];
            if(horCumulated==X.length/2)
        }
        
    }
}

Code: 07:13:27 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

// 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 M, int[] X, int[] Y) {
        int[] hor = new int[N];
        int[] ver = new int[M];
        for(int i=0;i<X.length;i++){
            hor[X[i]]++;
            ver[Y[i]]++;
        }
        
        int horCumulated = 0;
        int validSplits = 0;
        for(int i=0;i<N;i++){
            horCumulated+=hor[i];
            if(horCumulated==X.length/2){
                validSplits++;
            }
            else if(horCumulated>X.length/2){
                break;
            }
        }
        
    }
}

Code: 07:13: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 28 29 30 31 32 33 34 35 36 37 38

// 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 M, int[] X, int[] Y) {
        int[] hor = new int[N];
        int[] ver = new int[M];
        for(int i=0;i<X.length;i++){
            hor[X[i]]++;
            ver[Y[i]]++;
        }
        
        int horCumulated = 0;
        int validSplits = 0;
        for(int i=0;i<N;i++){
            horCumulated+=hor[i];
            if(horCumulated==X.length/2){
                validSplits++;
            }
            else if(horCumulated>X.length/2){
                break;
            }
        }
        for(int i=0;i<M;i++){
            horCumulated+=hor[i];
            if(horCumulated==X.length/2){
                validSplits++;
            }
            else if(horCumulated>X.length/2){
                break;
            }
        }
        
    }
}

Code: 07:14:12 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");

class Solution {
    public int solution(int N, int M, int[] X, int[] Y) {
        int[] hor = new int[N];
        int[] ver = new int[M];
        for(int i=0;i<X.length;i++){
            hor[X[i]]++;
            ver[Y[i]]++;
        }
        
        int horCumulated = 0;
        int validSplits = 0;
        for(int i=0;i<N;i++){
            horCumulated+=hor[i];
            if(horCumulated==X.length/2){
                validSplits++;
            }
            else if(horCumulated>X.length/2){
                break;
            }
        }
    }
    
    public int 
}

Code: 07:14:42 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");

class Solution {
    public int solution(int N, int M, int[] X, int[] Y) {
        int[] hor = new int[N];
        int[] ver = new int[M];
        for(int i=0;i<X.length;i++){
            hor[X[i]]++;
            ver[Y[i]]++;
        }
        
        int validSplits = validSplits(hor,);
        for(int i=0;i<N;i++){
            horCumulated+=hor[i];
            if(horCumulated==X.length/2){
                validSplits++;
            }
            else if(horCumulated>X.length/2){
                break;
            }
        }
    }
    
    public int validSplits(int[] rows, int target){
        
    }
}

Code: 07:14: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

// 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 M, int[] X, int[] Y) {
        int[] hor = new int[N];
        int[] ver = new int[M];
        for(int i=0;i<X.length;i++){
            hor[X[i]]++;
            ver[Y[i]]++;
        }
        
        int validSplits = validSplits(hor,X.length/2);
        for(int i=0;i<N;i++){
            horCumulated+=hor[i];
            if(horCumulated==X.length/2){
                validSplits++;
            }
            else if(horCumulated>X.length/2){
                break;
            }
        }
    }
    
    public int validSplits(int[] rows, int target){
        
    }
}

Code: 07:15: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 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");

class Solution {
    public int solution(int N, int M, int[] X, int[] Y) {
        int[] hor = new int[N];
        int[] ver = new int[M];
        for(int i=0;i<X.length;i++){
            hor[X[i]]++;
            ver[Y[i]]++;
        }
        
        int validSplits = validSplits(hor,X.length/2)+ validSplits(ver,X.length/2);
    }
    
    public int validSplits(int[] rows, int target){
        int cumulated = 0;
        for(int i=0;i<rows.length;i++){
            horCumulated+=hor[i];
            if(horCumulated==X.length/2){
                validSplits++;
            }
            else if(horCumulated>X.length/2){
                break;
            }
        }        
    }
}

Code: 07:15:37 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");

class Solution {
    public int solution(int N, int M, int[] X, int[] Y) {
        int[] hor = new int[N];
        int[] ver = new int[M];
        for(int i=0;i<X.length;i++){
            hor[X[i]]++;
            ver[Y[i]]++;
        }
        
        int validSplits = validSplits(hor,X.length/2)+ validSplits(ver,X.length/2);
    }
    
    public int validSplits(int[] rows, int target){
        int cumulated = 0;
        for(int i=0;i<rows.length;i++){
            cumulated+=rows[i];
            if(cumulated==X.length/2){
                validSplits++;
            }
            else if(horCumulated>X.length/2){
                break;
            }
        }        
    }
}

Code: 07:15: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 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");

class Solution {
    public int solution(int N, int M, int[] X, int[] Y) {
        int[] hor = new int[N];
        int[] ver = new int[M];
        for(int i=0;i<X.length;i++){
            hor[X[i]]++;
            ver[Y[i]]++;
        }
        
        int validSplits = validSplits(hor,X.length/2)+ validSplits(ver,X.length/2);
    }
    
    public int validSplits(int[] rows, int target){
        int cumulated = 0;
        for(int i=0;i<rows.length;i++){
            cumulated+=rows[i];
            if(cumulated==target){
                validSplits++;
            }
            else if(horCumulated>target){
                break;
            }
        }        
    }
}

Code: 07: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 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");

class Solution {
    public int solution(int N, int M, int[] X, int[] Y) {
        int[] hor = new int[N];
        int[] ver = new int[M];
        for(int i=0;i<X.length;i++){
            hor[X[i]]++;
            ver[Y[i]]++;
        }
        
        int validSplits = validSplits(hor,X.length/2)+ validSplits(ver,X.length/2);
    }
    
    public int validSplits(int[] rows, int target){
        int cumulated = 0;
        int validSplits = 0;
        for(int i=0;i<rows.length;i++){
            cumulated+=rows[i];
            if(cumulated==target){
                validSplits++;
            }
            else if(horCumulated>target){
                break;
            }
        }        
        return validSplits;
    }
}

Code: 07:16:03 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");

class Solution {
    public int solution(int N, int M, int[] X, int[] Y) {
        int[] hor = new int[N];
        int[] ver = new int[M];
        for(int i=0;i<X.length;i++){
            hor[X[i]]++;
            ver[Y[i]]++;
        }
        
        int validSplits = validSplits(hor,X.length/2)+ validSplits(ver,X.length/2);
    }
    
    public int validSplits(int[] rows, int target){
        int cumulated = 0;
        int validSplits = 0;
        for(int i=0;i<rows.length;i++){
            cumulated+=rows[i];
            if(cumulated==target){
                validSplits++;
            }
            else if(horCumulated>target){
                break;
            }
        }        
        return validSplits;
    }
}

Analysis

Compile error

Solution.java:27: error: cannot find symbol
            else if(horCumulated>target){
                    ^
  symbol:   variable horCumulated
  location: class Solution
1 error

Code: 07:16:13 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");

class Solution {
    public int solution(int N, int M, int[] X, int[] Y) {
        int[] hor = new int[N];
        int[] ver = new int[M];
        for(int i=0;i<X.length;i++){
            hor[X[i]]++;
            ver[Y[i]]++;
        }
        
        int validSplits = validSplits(hor,X.length/2)+ validSplits(ver,X.length/2);
    }
    
    public int validSplits(int[] rows, int target){
        int cumulated = 0;
        int validSplits = 0;
        for(int i=0;i<rows.length;i++){
            cumulated+=rows[i];
            if(cumulated==target){
                validSplits++;
            }
            else if(cumulated>target){
                break;
            }
        }        
        return validSplits;
    }
}

Analysis

Compile error

Solution.java:17: error: missing return statement
    }
    ^
1 error

Code: 07:16:32 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");

class Solution {
    public int solution(int N, int M, int[] X, int[] Y) {
        int[] hor = new int[N];
        int[] ver = new int[M];
        for(int i=0;i<X.length;i++){
            hor[X[i]]++;
            ver[Y[i]]++;
        }
        
        return validSplits(hor,X.length/2)+ validSplits(ver,X.length/2);
    }
    
    public int validSplits(int[] rows, int target){
        int cumulated = 0;
        int validSplits = 0;
        for(int i=0;i<rows.length;i++){
            cumulated+=rows[i];
            if(cumulated==target){
                validSplits++;
            }
            else if(cumulated>target){
                break;
            }
        }        
        return validSplits;
    }
}

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

// 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 M, int[] X, int[] Y) {
        int[] hor = new int[N];
        int[] ver = new int[M];
        for(int i=0;i<X.length;i++){
            hor[X[i]]++;
            ver[Y[i]]++;
        }
        
        return validSplits(hor,X.length/2)+ validSplits(ver,X.length/2);
    }
    
    public int validSplits(int[] rows, int target){
        int cumulated = 0;
        int validSplits = 0;
        for(int i=0;i<rows.length;i++){
            cumulated+=rows[i];
            if(cumulated==target){
                validSplits++;
            }
            else if(cumulated>target){
                break;
            }
        }        
        return validSplits;
    }
}

Analysis

expand all Example tests

▶

example
example test

✔

0.004 s

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

// 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 M, int[] X, int[] Y) {
        int[] hor = new int[N];
        int[] ver = new int[M];
        for(int i=0;i<X.length;i++){
            hor[X[i]]++;
            ver[Y[i]]++;
        }
        return validSplits(hor,X.length/2)+ validSplits(ver,X.length/2);
    }
    
    public int validSplits(int[] rows, int target){
        int cumulated = 0;
        int validSplits = 0;
        for(int i=0;i<rows.length;i++){
            cumulated+=rows[i];
            if(cumulated==target){
                validSplits++;
            }
            else if(cumulated>target){
                break;
            }
        }        
        return validSplits;
    }
}

Code: 07:17:49 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");

class Solution {
    public int solution(int N, int M, int[] X, int[] Y) {
        int[] hor = new int[N];
        int[] ver = new int[M];
        
        for(int i=0;i<X.length;i++){
            hor[X[i]]++;
            ver[Y[i]]++;
        }
        return validSplits(hor,X.length/2)+ validSplits(ver,X.length/2);
    }
    
    public int validSplits(int[] rows, int target){
        int cumulated = 0;
        int validSplits = 0;
        for(int i=0;i<rows.length;i++){
            cumulated+=rows[i];
            if(cumulated==target){
                validSplits++;
            }
            else if(cumulated>target){
                break;
            }
        }        
        return validSplits;
    }
}

Code: 07:18:04 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");

class Solution {
    public int solution(int N, int M, int[] X, int[] Y) {
        if(X.length%2==1) return 0;
        int[] hor = new int[N];
        int[] ver = new int[M];
        for(int i=0;i<X.length;i++){
            hor[X[i]]++;
            ver[Y[i]]++;
        }
        return validSplits(hor,X.length/2)+ validSplits(ver,X.length/2);
    }
    
    public int validSplits(int[] rows, int target){
        int cumulated = 0;
        int validSplits = 0;
        for(int i=0;i<rows.length;i++){
            cumulated+=rows[i];
            if(cumulated==target){
                validSplits++;
            }
            else if(cumulated>target){
                break;
            }
        }        
        return validSplits;
    }
}

Code: 07:18: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

// 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 M, int[] X, int[] Y) {
        if(X.length%2==1) return 0;
        
        int[] hor = new int[N];
        int[] ver = new int[M];
        for(int i=0;i<X.length;i++){
            hor[X[i]]++;
            ver[Y[i]]++;
        }
        return validSplits(hor,X.length/2)+ validSplits(ver,X.length/2);
    }
    
    public int validSplits(int[] rows, int target){
        int cumulated = 0;
        int validSplits = 0;
        for(int i=0;i<rows.length;i++){
            cumulated+=rows[i];
            if(cumulated==target){
                validSplits++;
            }
            else if(cumulated>target){
                break;
            }
        }        
        return validSplits;
    }
}

Code: 07:18:12 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

// 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 M, int[] X, int[] Y) {
        if(X.length%2==1) return 0;
        
        int[] hor = new int[N];
        int[] ver = new int[M];
        for(int i=0;i<X.length;i++){
            hor[X[i]]++;
            ver[Y[i]]++;
        }
        return validSplits(hor,X.length/2)+ validSplits(ver,X.length/2);
    }
    
    public int validSplits(int[] rows, int target){
        int cumulated = 0;
        int validSplits = 0;
        for(int i=0;i<rows.length;i++){
            cumulated+=rows[i];
            if(cumulated==target){
                validSplits++;
            }
            else if(cumulated>target){
                break;
            }
        }        
        return validSplits;
    }
}

Analysis

expand all Example tests

▶

example
example test

✔

0.008 s

Code: 07:18:17 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

// 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 M, int[] X, int[] Y) {
        if(X.length%2==1) return 0;
        
        int[] hor = new int[N];
        int[] ver = new int[M];
        for(int i=0;i<X.length;i++){
            hor[X[i]]++;
            ver[Y[i]]++;
        }
        return validSplits(hor,X.length/2)+ validSplits(ver,X.length/2);
    }
    
    public int validSplits(int[] rows, int target){
        int cumulated = 0;
        int validSplits = 0;
        for(int i=0;i<rows.length;i++){
            cumulated+=rows[i];
            if(cumulated==target){
                validSplits++;
            }
            else if(cumulated>target){
                break;
            }
        }        
        return validSplits;
    }
}

Analysis

expand all Example tests

▶

example
example test

✔

0.004 s

Code: 07:18:21 UTC, java, final, score: 100

show code in pop-up

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

// 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 M, int[] X, int[] Y) {
        if(X.length%2==1) return 0;
        
        int[] hor = new int[N];
        int[] ver = new int[M];
        for(int i=0;i<X.length;i++){
            hor[X[i]]++;
            ver[Y[i]]++;
        }
        return validSplits(hor,X.length/2)+ validSplits(ver,X.length/2);
    }
    
    public int validSplits(int[] rows, int target){
        int cumulated = 0;
        int validSplits = 0;
        for(int i=0;i<rows.length;i++){
            cumulated+=rows[i];
            if(cumulated==target){
                validSplits++;
            }
            else if(cumulated>target){
                break;
            }
        }        
        return validSplits;
    }
}

Analysis summary

The solution obtained perfect score.

Analysis

Detected time complexity:

O(N+M+K)

expand all Example tests

▶

example
example test

✔

0.004 s

expand all Correctness tests

▶

one_column
simple test with one column

✔

0.004 s

▶

one_row
simple test with one row

✔

0.004 s

▶

simple_mostly_zeroes
simple test with mostly zeroes in array

✔

0.008 s

▶

combinations
multiple runs, all legal sequences of length 3

✔

0.004 s

10.

0.004 s

11.

0.004 s

12.

0.004 s

13.

0.004 s

14.

0.004 s

▶

random_small
small random tests

✔

0.004 s

▶

diagonal_permutation
goldmines lie on diagonal, but are given in random order

✔

0.004 s

expand all Performance tests

▶

random_large
large random tests

✔

0.004 s

0.008 s

0.380 s

▶

random_long
random tests with many rows or many columns

✔

0.008 s

0.080 s

▶

random_square
random tests with many rows and many columns

✔

0.008 s

0.488 s

▶

largest_answer
max test with largest answer

✔

0.008 s