Test results - Codility

Tasks Details

medium

1. MaxCounters

Calculate the values of counters after applying all alternating operations: increase counter by 1; set value of all counters to current maximum.

Task Score

100%

Correctness

100%

Performance

100%

You are given N counters, initially set to 0, and you have two possible operations on them:

increase(X) − counter X is increased by 1,

max counter − all counters are set to the maximum value of any counter.

A non-empty array A of M integers is given. This array represents consecutive operations:

if A[K] = X, such that 1 ≤ X ≤ N, then operation K is increase(X),

if A[K] = N + 1 then operation K is max counter.

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

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

the values of the counters after each consecutive operation will be:

(0, 0, 1, 0, 0) (0, 0, 1, 1, 0) (0, 0, 1, 2, 0) (2, 2, 2, 2, 2) (3, 2, 2, 2, 2) (3, 2, 2, 3, 2) (3, 2, 2, 4, 2)

The goal is to calculate the value of every counter after all operations.

Write a function:

class Solution { public int[] solution(int N, int[] A); }

that, given an integer N and a non-empty array A consisting of M integers, returns a sequence of integers representing the values of the counters.

Result array should be returned as an array of integers.

For example, given:

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

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

Write an efficient algorithm for the following assumptions:

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

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

Solution

Programming language used Java 8

Time spent on task 7 minutes

Notes

not defined yet

Code: 13:33:01 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[] A) {
        // write your code in Java SE 8
    }
}

Code: 13:33:29 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

import java.util.*;

class Solution {
    public int[] solution(int N, int[] A) {
        int[] counter = new int[N];
        int max = 0;
        int maxCountVal = 0;
        
        for (int a : A) {
            if (a < N) {
                a--;
                if (counter[a] < maxCountVal) {
                    counter[a] = maxCountVal;
                }
                
                counter[a]++;   
                
                if (max < counter[a]) {
                    max = counter[a];
                }
            } else {
                maxCountVal = max;
            }
        }
        
        for (int i = 0; i < counter.length; i++) {
            if (counter[i] < maxCountVal) {
                counter[i] = maxCountVal;
            }
        }
        
        return counter;
    }
}

Code: 13:35: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

import java.util.*;

class Solution {
    public int[] solution(int N, int[] A) {
        int[] counter = new int[N];
        int max = 0;
        int maxCountVal = 0;
        
        for (int a : A) {
            if (a < N) {
                a--;
                if (counter[a] < maxCountVal) {
                    counter[a] = maxCountVal;
                }
                
                counter[a]++;   
                
                if (max < counter[a]) {
                    max = counter[a];
                }
            } else {
                maxCountVal = max;
            }
        }
        
        for (int i = 0; i < counter.length; i++) {
            if (counter[i] < maxCountVal) {
                counter[i] = maxCountVal;
            }
        }
        
        return counter;
    }
}

User test case 1:

[1, [1]]

Analysis

expand all Example tests

▶

example
example test

✔

0.004 s

expand all User tests

▶

test_data1

✔

0.008 s

OK
function result: [0]

Code: 13:36:00 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

import java.util.*;

class Solution {
    public int[] solution(int N, int[] A) {
        int[] counter = new int[N];
        int max = 0;
        int maxCountVal = 0;
        
        for (int a : A) {
            if (a < N) {
                a--;
                if (counter[a] < maxCountVal) {
                    counter[a] = maxCountVal;
                }
                
                counter[a]++;   
                
                if (max < counter[a]) {
                    max = counter[a];
                }
            } else {
                maxCountVal = max;
            }
        }
        
        for (int i = 0; i < counter.length; i++) {
            if (counter[i] < maxCountVal) {
                counter[i] = maxCountVal;
            }
        }
        
        return counter;
    }
}

User test case 1:

[1, [1]]

Analysis

expand all Example tests

▶

example
example test

✔

0.004 s

expand all User tests

▶

test_data1

✔

0.004 s

OK
function result: [0]

Code: 13:36:53 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

import java.util.*;

class Solution {
    public int[] solution(int N, int[] A) {
        int[] counter = new int[N];
        int max = 0;
        int maxCountVal = 0;
        
        for (int a : A) {
            if (a < N) {
                a--;
                if (counter[a] < maxCountVal) {
                    counter[a] = maxCountVal;
                }
                
                counter[a]++;   
                
                if (max < counter[a]) {
                    max = counter[a];
                }
            } else {
                maxCountVal = max;
            }
        }
        
        for (int i = 0; i < counter.length; i++) {
            if (counter[i] < maxCountVal) {
                counter[i] = maxCountVal;
            }
        }
        
        return counter;
    }
}

User test case 1:

[1, [1]]

Analysis

expand all Example tests

▶

example
example test

✔

0.004 s

expand all User tests

▶

test_data1

✔

0.004 s

OK
function result: [0]

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

import java.util.*;

class Solution {
    public int[] solution(int N, int[] A) {
        int[] counter = new int[N];
        int max = 0;
        int maxCountVal = 0;
        
        for (int a : A) {
            if (a < N) {
                a--;
                if (counter[a] < maxCountVal) {
                    counter[a] = maxCountVal;
                }
                
                counter[a]++;   
                
                if (max < counter[a]) {
                    max = counter[a];
                }
            } else {
                maxCountVal = max;
            }
            
            
        }
        
        for (int i = 0; i < counter.length; i++) {
            if (counter[i] < maxCountVal) {
                counter[i] = maxCountVal;
            }
        }
        
        return counter;
    }
}

Code: 13:37: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 35 36 37 38

import java.util.*;

class Solution {
    public int[] solution(int N, int[] A) {
        int[] counter = new int[N];
        int max = 0;
        int maxCountVal = 0;
        
        for (int a : A) {
            if (a < N) {
                a--;
                if (counter[a] < maxCountVal) {
                    counter[a] = maxCountVal;
                }
                
                counter[a]++;   
                
                if (max < counter[a]) {
                    max = counter[a];
                }
            } else {
                maxCountVal = max;
            }
            
            for (int c : counter) {
                
            }
        }
        
        for (int i = 0; i < counter.length; i++) {
            if (counter[i] < maxCountVal) {
                counter[i] = maxCountVal;
            }
        }
        
        return counter;
    }
}

Code: 13:37:50 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 36 37 38 39 40

import java.util.*;

class Solution {
    public int[] solution(int N, int[] A) {
        int[] counter = new int[N];
        int max = 0;
        int maxCountVal = 0;
        
        for (int a : A) {
            if (a < N) {
                a--;
                if (counter[a] < maxCountVal) {
                    counter[a] = maxCountVal;
                }
                
                counter[a]++;   
                
                if (max < counter[a]) {
                    max = counter[a];
                }
            } else {
                maxCountVal = max;
            }
            
            for (int c : counter) {
                System.out.print(c + " ");
            }
            
            System.out.print();
        }
        
        for (int i = 0; i < counter.length; i++) {
            if (counter[i] < maxCountVal) {
                counter[i] = maxCountVal;
            }
        }
        
        return counter;
    }
}

Analysis

Compile error

Solution.java:29: error: no suitable method found for print(no arguments)
            System.out.print();
                      ^
    method PrintStream.print(boolean) is not applicable
      (actual and formal argument lists differ in length)
    method PrintStream.print(char) is not applicable
      (actual and formal argument lists differ in length)
    method PrintStream.print(int) is not applicable
      (actual and formal argument lists differ in length)
    method PrintStream.print(long) is not applicable
      (actual and formal argument lists differ in length)
    method PrintStream.print(float) is not applicable
      (actual and formal argument lists differ in length)
    method PrintStream.print(double) is not applicable
      (actual and formal argument lists differ in length)
    method PrintStream.print(char[]) is not applicable
      (actual and formal argument lists differ in length)
    method PrintStream.print(String) is not applicable
      (actual and formal argument lists differ in length)
    method PrintStream.print(Object) is not applicable
      (actual and formal argument lists differ in length)
1 error

Code: 13:38:38 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 36 37 38 39 40

import java.util.*;

class Solution {
    public int[] solution(int N, int[] A) {
        int[] counter = new int[N];
        int max = 0;
        int maxCountVal = 0;
        
        for (int a : A) {
            if (a < N) {
                a--;
                if (counter[a] < maxCountVal) {
                    counter[a] = maxCountVal;
                }
                
                counter[a]++;   
                
                if (max < counter[a]) {
                    max = counter[a];
                }
            } else {
                maxCountVal = max;
            }
            
            for (int c : counter) {
                System.out.print(c + " ");
            }
            
            System.out.print();
        }
        
        for (int i = 0; i < counter.length; i++) {
            if (counter[i] < maxCountVal) {
                counter[i] = maxCountVal;
            }
        }
        
        return counter;
    }
}

Analysis

Compile error

Solution.java:29: error: no suitable method found for print(no arguments)
            System.out.print();
                      ^
    method PrintStream.print(boolean) is not applicable
      (actual and formal argument lists differ in length)
    method PrintStream.print(char) is not applicable
      (actual and formal argument lists differ in length)
    method PrintStream.print(int) is not applicable
      (actual and formal argument lists differ in length)
    method PrintStream.print(long) is not applicable
      (actual and formal argument lists differ in length)
    method PrintStream.print(float) is not applicable
      (actual and formal argument lists differ in length)
    method PrintStream.print(double) is not applicable
      (actual and formal argument lists differ in length)
    method PrintStream.print(char[]) is not applicable
      (actual and formal argument lists differ in length)
    method PrintStream.print(String) is not applicable
      (actual and formal argument lists differ in length)
    method PrintStream.print(Object) is not applicable
      (actual and formal argument lists differ in length)
1 error

Code: 13:38: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 35 36 37 38 39 40

import java.util.*;

class Solution {
    public int[] solution(int N, int[] A) {
        int[] counter = new int[N];
        int max = 0;
        int maxCountVal = 0;
        
        for (int a : A) {
            if (a < N) {
                a--;
                if (counter[a] < maxCountVal) {
                    counter[a] = maxCountVal;
                }
                
                counter[a]++;   
                
                if (max < counter[a]) {
                    max = counter[a];
                }
            } else {
                maxCountVal = max;
            }
            
            for (int c : counter) {
                System.out.print(c + " ");
            }
            
            System.out.println();
        }
        
        for (int i = 0; i < counter.length; i++) {
            if (counter[i] < maxCountVal) {
                counter[i] = maxCountVal;
            }
        }
        
        return counter;
    }
}

Code: 13:38:52 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 36 37 38 39 40

import java.util.*;

class Solution {
    public int[] solution(int N, int[] A) {
        int[] counter = new int[N];
        int max = 0;
        int maxCountVal = 0;
        
        for (int a : A) {
            if (a < N) {
                a--;
                if (counter[a] < maxCountVal) {
                    counter[a] = maxCountVal;
                }
                
                counter[a]++;   
                
                if (max < counter[a]) {
                    max = counter[a];
                }
            } else {
                maxCountVal = max;
            }
            
            for (int c : counter) {
                System.out.print(c + " ");
            }
            
            System.out.println();
        }
        
        for (int i = 0; i < counter.length; i++) {
            if (counter[i] < maxCountVal) {
                counter[i] = maxCountVal;
            }
        }
        
        return counter;
    }
}

User test case 1:

[1, [1]]

Analysis

expand all Example tests

▶

example
example test

✔

0.004 s

stdout:

expand all User tests

▶

test_data1

✔

0.004 s

OK
function result: [0]

stdout:

Code: 13:39:10 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 36 37 38 39 40

import java.util.*;

class Solution {
    public int[] solution(int N, int[] A) {
        int[] counter = new int[N];
        int max = 0;
        int maxCountVal = 0;
        
        for (int a : A) {
            if (a <= N) {
                a--;
                if (counter[a] < maxCountVal) {
                    counter[a] = maxCountVal;
                }
                
                counter[a]++;   
                
                if (max < counter[a]) {
                    max = counter[a];
                }
            } else {
                maxCountVal = max;
            }
            
            for (int c : counter) {
                System.out.print(c + " ");
            }
            
            System.out.println();
        }
        
        for (int i = 0; i < counter.length; i++) {
            if (counter[i] < maxCountVal) {
                counter[i] = maxCountVal;
            }
        }
        
        return counter;
    }
}

User test case 1:

[1, [1]]

Analysis

expand all Example tests

▶

example
example test

✔

0.008 s

stdout:

expand all User tests

▶

test_data1

✔

0.004 s

OK
function result: [1]

stdout:

Code: 13:39:20 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

import java.util.*;

class Solution {
    public int[] solution(int N, int[] A) {
        int[] counter = new int[N];
        int max = 0;
        int maxCountVal = 0;
        
        for (int a : A) {
            if (a <= N) {
                a--;
                if (counter[a] < maxCountVal) {
                    counter[a] = maxCountVal;
                }
                
                counter[a]++;   
                
                if (max < counter[a]) {
                    max = counter[a];
                }
            } else {
                maxCountVal = max;
            }
        }
        
        for (int i = 0; i < counter.length; i++) {
            if (counter[i] < maxCountVal) {
                counter[i] = maxCountVal;
            }
        }
        
        return counter;
    }
}

Code: 13:39:20 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

import java.util.*;

class Solution {
    public int[] solution(int N, int[] A) {
        int[] counter = new int[N];
        int max = 0;
        int maxCountVal = 0;
        
        for (int a : A) {
            if (a <= N) {
                a--;
                if (counter[a] < maxCountVal) {
                    counter[a] = maxCountVal;
                }
                
                counter[a]++;   
                
                if (max < counter[a]) {
                    max = counter[a];
                }
            } else {
                maxCountVal = max;
            }
        }
        
        for (int i = 0; i < counter.length; i++) {
            if (counter[i] < maxCountVal) {
                counter[i] = maxCountVal;
            }
        }
        
        return counter;
    }
}

User test case 1:

[1, [1]]

Analysis

expand all Example tests

▶

example
example test

✔

0.004 s

expand all User tests

▶

test_data1

✔

0.004 s

OK
function result: [1]

Code: 13:39:25 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

import java.util.*;

class Solution {
    public int[] solution(int N, int[] A) {
        int[] counter = new int[N];
        int max = 0;
        int maxCountVal = 0;
        
        for (int a : A) {
            if (a <= N) {
                a--;
                if (counter[a] < maxCountVal) {
                    counter[a] = maxCountVal;
                }
                
                counter[a]++;   
                
                if (max < counter[a]) {
                    max = counter[a];
                }
            } else {
                maxCountVal = max;
            }
        }
        
        for (int i = 0; i < counter.length; i++) {
            if (counter[i] < maxCountVal) {
                counter[i] = maxCountVal;
            }
        }
        
        return counter;
    }
}

Analysis summary

The solution obtained perfect score.

Analysis

Detected time complexity:

O(N + M)

expand all Example tests

▶

example
example test

✔

0.004 s

expand all Correctness tests

▶

extreme_small
all max_counter operations

✔

0.004 s

▶

single
only one counter

✔

0.004 s

▶

small_random1
small random test, 6 max_counter operations

✔

0.004 s

▶

small_random2
small random test, 10 max_counter operations

✔

0.004 s

expand all Performance tests

▶

medium_random1
medium random test, 50 max_counter operations

✔

0.016 s

▶

medium_random2
medium random test, 500 max_counter operations

✔

0.016 s

▶

large_random1
large random test, 2120 max_counter operations

✔

0.396 s

▶

large_random2
large random test, 10000 max_counter operations

✔

0.560 s

▶

extreme_large
all max_counter operations

✔

1.304 s

1.204 s