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] = 4the 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] = 4the 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].
Copyright 2009–2025 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Solution
Programming language used Java 21
Time spent on task 25 minutes
Notes
not defined yet
Code: 09:50:25 UTC,
java,
autosave
Code: 09:50:36 UTC,
java,
autosave
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
for(int j=0;j<cntArr.length; j++){
cntArr[j] = max;
}
}else{
cntArr[A[i]-1]++;
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
}
return cntArr;
}
}
Code: 09:50:37 UTC,
java,
verify,
result: Passed
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
for(int j=0;j<cntArr.length; j++){
cntArr[j] = max;
}
}else{
cntArr[A[i]-1]++;
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
}
return cntArr;
}
}
Analysis
Code: 09:50:52 UTC,
java,
autosave
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
for(int j=0;j<cntArr.length; j++){
cntArr[j] = max;
}
}else{
cntArr[A[i]-1]++;
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
}
return cntArr;
}
}
Code: 09:51:00 UTC,
java,
verify,
result: Passed
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
for(int j=0;j<cntArr.length; j++){
cntArr[j] = max;
}
}else{
cntArr[A[i]-1]++;
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
}
return cntArr;
}
}
Analysis
User test case 1:
[5, [3, 4, 4, 6, 1, 6, 4]]
Code: 09:51:25 UTC,
java,
autosave
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
for(int j=0;j<cntArr.length; j++){
cntArr[j] = max;
}
}else{
cntArr[A[i]-1]++;
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
}
return cntArr;
}
}
Code: 09:51:40 UTC,
java,
autosave
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
for(int j=0;j<cntArr.length; j++){
cntArr[j] = max;
}
}else{
cntArr[A[i]-1]++;
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
System.out.print();
}
return cntArr;
}
}
Code: 09:51:53 UTC,
java,
autosave
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
for(int j=0;j<cntArr.length; j++){
cntArr[j] = max;
}
}else{
cntArr[A[i]-1]++;
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<)
System.out.print();
}
return cntArr;
}
}
Code: 09:52:13 UTC,
java,
autosave
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
for(int j=0;j<cntArr.length; j++){
cntArr[j] = max;
}
}else{
cntArr[A[i]-1]++;
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;K++){
System.out.print();
}
}
return cntArr;
}
}
Code: 09:52:21 UTC,
java,
autosave
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
for(int j=0;j<cntArr.length; j++){
cntArr[j] = max;
}
}else{
cntArr[A[i]-1]++;
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;K++){
System.out.print(cntArr[k] + " ");
}
}
return cntArr;
}
}
Code: 09:52:21 UTC,
java,
verify,
result: Failed
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
for(int j=0;j<cntArr.length; j++){
cntArr[j] = max;
}
}else{
cntArr[A[i]-1]++;
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;K++){
System.out.print(cntArr[k] + " ");
}
}
return cntArr;
}
}
Analysis
Compile error
Solution.java:16: error: cannot find symbol
for(int k=0;k<cntArr.length;K++){
^
symbol: variable K
location: class Solution
1 error
Code: 09:52:30 UTC,
java,
verify,
result: Passed
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
for(int j=0;j<cntArr.length; j++){
cntArr[j] = max;
}
}else{
cntArr[A[i]-1]++;
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
}
return cntArr;
}
}
Analysis
expand all
Example tests
1.
0.008 s
OK
stdout:
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
expand all
User tests
1.
0.008 s
OK
function result: [3, 3, 3, 4, 3]
function result: [3, 3, 3, 4, 3]
stdout:
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 3 3 3 3 3 3 3 4 3
User test case 1:
[5, [3, 4, 4, 6, 1, 6, 4]]
Code: 09:52:42 UTC,
java,
autosave
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
for(int j=0;j<cntArr.length; j++){
cntArr[j] = max;
}
}else{
cntArr[A[i]-1]++;
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
System.out.print(cntArr[k] + " ");
}
return cntArr;
}
}
Code: 09:52:50 UTC,
java,
verify,
result: Passed
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
for(int j=0;j<cntArr.length; j++){
cntArr[j] = max;
}
}else{
cntArr[A[i]-1]++;
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
System.out.println("");
}
return cntArr;
}
}
Analysis
expand all
Example tests
1.
0.012 s
OK
stdout:
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
expand all
User tests
1.
0.004 s
OK
function result: [3, 3, 3, 4, 3]
function result: [3, 3, 3, 4, 3]
stdout:
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 3 3 3 3 3 3 3 4 3
User test case 1:
[5, [3, 4, 4, 6, 1, 6, 4]]
Code: 10:02:51 UTC,
java,
autosave
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
for(int j=0;j<cntArr.length; j++){
cntArr[j] = max;
}
}else{
cntArr[A[i]-1]++;
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
System.out.println("");
}
return cntArr;
}
}
Code: 10:03:01 UTC,
java,
autosave
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int tmpMAx = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
for(int j=0;j<cntArr.length; j++){
cntArr[j] = max;
}
}else{
cntArr[A[i]-1]++;
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
System.out.println("");
}
return cntArr;
}
}
Code: 10:03:14 UTC,
java,
autosave
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int tmpMAx = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
tmpMax = max;
}else{
cntArr[A[i]-1]++;
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
System.out.println("");
}
return cntArr;
}
}
Code: 10:03:46 UTC,
java,
autosave
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int tmpMax = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
tmpMax = max;
}else{
cntArr[A[i]-1]++;
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
System.out.println("");
}
return cntArr;
}
}
Code: 10:04:00 UTC,
java,
autosave
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int tmpMax = 0;
int tmp = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
tmpMax = max;
}else{
tmp = cntArr[A[i]-1]++;
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
System.out.println("");
}
return cntArr;
}
}
Code: 10:04:17 UTC,
java,
autosave
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int tmpMax = 0;
int tmp = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
tmpMax = max;
}else{
tmp = tmpMax + cntArr[A[i]-1]++;
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
System.out.println("");
}
return cntArr;
}
}
Code: 10:04:43 UTC,
java,
autosave
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int tmpMax = 0;
int tmp = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
tmpMax = max;
}else{
cntArr[A[i]-1] = tmpMax + cntArr[A[i]-1]++;
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
System.out.println("");
}
return cntArr;
}
}
Code: 10:04:53 UTC,
java,
autosave
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int tmpMax = 0;
int tmp = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
tmpMax = max;
}else{
cntArr[A[i]-1] = tmpMax + 1;
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
System.out.println("");
}
return cntArr;
}
}
Code: 10:04:56 UTC,
java,
verify,
result: Failed
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int tmpMax = 0;
int tmp = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
tmpMax = max;
}else{
cntArr[A[i]-1] = tmpMax + 1;
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
System.out.println("");
}
return cntArr;
}
}
Analysis
expand all
Example tests
1.
0.008 s
WRONG ANSWER,
got [2, 0, 1, 2, 0] expected [3, 2, 2, 4, 2]
stdout:
0 0 1 0 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1 0 2 0 1 1 0 2 0 1 2 0 2 0 1 2 0
expand all
User tests
1.
0.008 s
OK
function result: [2, 0, 1, 3, 0]
function result: [2, 0, 1, 3, 0]
stdout:
0 0 1 0 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1 0 2 0 1 1 0 2 0 1 1 0 2 0 1 3 0
User test case 1:
[5, [3, 4, 4, 6, 1, 6, 4]]
Code: 10:05:36 UTC,
java,
autosave
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int tmpMax = 0;
int tmp = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
tmpMax = max+;
}else{
cntArr[A[i]-1] = tmpMax + 1;
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
System.out.println("");
}
return cntArr;
}
}
Code: 10:05:40 UTC,
java,
verify,
result: Failed
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int tmpMax = 0;
int tmp = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
tmpMax = max+1;
}else{
cntArr[A[i]-1] = tmpMax + 1;
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
System.out.println("");
}
return cntArr;
}
}
Analysis
expand all
Example tests
1.
0.012 s
WRONG ANSWER,
got [3, 0, 1, 3, 0] expected [3, 2, 2, 4, 2]
stdout:
0 0 1 0 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1 0 3 0 1 1 0 3 0 1 3 0 3 0 1 3 0
expand all
User tests
1.
0.012 s
OK
function result: [3, 0, 1, 5, 0]
function result: [3, 0, 1, 5, 0]
stdout:
0 0 1 0 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1 0 3 0 1 1 0 3 0 1 1 0 3 0 1 5 0
User test case 1:
[5, [3, 4, 4, 6, 1, 6, 4]]
Code: 10:10:00 UTC,
java,
autosave
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int tmpMax = 0;
int tmp = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
tmpMax = max+1;
}else{
cntArr[A[i]-1] = tmpMax + 1;
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
System.out.println("");
}
return cntArr;
}
}
Code: 10:10:21 UTC,
java,
autosave
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int tmpMax = 0;
int tmp = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
tmpMax = max+1;
}else{
if( tmpMax < max ){
}else{
cntArr[A[i]-1] = tmpMax + 1;
}
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
System.out.println("");
}
return cntArr;
}
}
Code: 10:10:30 UTC,
java,
verify,
result: Failed
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int tmpMax = 0;
int tmp = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
tmpMax = max+1;
}else{
if( tmpMax < max ){
cntArr[A[i]-1] = max + 1;
}else{
cntArr[A[i]-1] = tmpMax + 1;
}
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
System.out.println("");
}
return cntArr;
}
}
Analysis
expand all
Example tests
1.
0.008 s
WRONG ANSWER,
got [5, 0, 1, 7, 0] expected [3, 2, 2, 4, 2]
stdout:
0 0 1 0 0 0 0 1 2 0 0 0 1 3 0 0 0 1 3 0 5 0 1 3 0 5 0 1 6 0 5 0 1 7 0
expand all
User tests
1.
0.008 s
OK
function result: [5, 0, 1, 7, 0]
function result: [5, 0, 1, 7, 0]
stdout:
0 0 1 0 0 0 0 1 2 0 0 0 1 3 0 0 0 1 3 0 5 0 1 3 0 5 0 1 3 0 5 0 1 7 0
User test case 1:
[5, [3, 4, 4, 6, 1, 6, 4]]
Code: 10:10:54 UTC,
java,
autosave
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int tmpMax = 0;
int tmp = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
tmpMax = max+1;
}else{
cntArr[A[i]-1] = tmpMax + 1;
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
System.out.println("");
}
return cntArr;
}
}
Code: 10:11:00 UTC,
java,
verify,
result: Failed
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int tmpMax = 0;
int tmp = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
tmpMax = max+1;
}else{
cntArr[A[i]-1] = tmpMax + 1;
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
System.out.println("");
}
return cntArr;
}
}
Analysis
expand all
Example tests
1.
0.012 s
WRONG ANSWER,
got [3, 0, 1, 3, 0] expected [3, 2, 2, 4, 2]
stdout:
0 0 1 0 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1 0 3 0 1 1 0 3 0 1 3 0 3 0 1 3 0
expand all
User tests
1.
0.012 s
OK
function result: [3, 0, 1, 5, 0]
function result: [3, 0, 1, 5, 0]
stdout:
0 0 1 0 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1 0 3 0 1 1 0 3 0 1 1 0 3 0 1 5 0
User test case 1:
[5, [3, 4, 4, 6, 1, 6, 4]]
Code: 10:12:02 UTC,
java,
autosave
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int tmpMax = 0;
int tmp = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
tmpMax = max+1;
}else{
cntArr[A[i]-1] = tmpMax + 1;
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
System.out.println("");
}
return cntArr;
}
}
Code: 10:12:13 UTC,
java,
autosave
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int tmpMax = 0;
int tmp = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
tmpMax = max+1;
}else{
if( tmpMax < max ){
cntArr[A[i]-1] = 1;
}else{
cntArr[A[i]-1] = tmpMax + 1;
}
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
System.out.println("");
}
return cntArr;
}
}
Code: 10:12:24 UTC,
java,
autosave
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int tmpMax = 0;
int tmp = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
tmpMax = max+1;
}else{
if( tmpMax < cntArr[A[i]-1] ){
cntArr[A[i]-1] = 1;
}else{
cntArr[A[i]-1] = tmpMax + 1;
}
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
System.out.println("");
}
return cntArr;
}
}
Code: 10:12:30 UTC,
java,
verify,
result: Failed
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int tmpMax = 0;
int tmp = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
tmpMax = max+1;
}else{
if( tmpMax < cntArr[A[i]-1] ){
cntArr[A[i]-1] = 1;
}else{
cntArr[A[i]-1] = tmpMax + 1;
}
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
System.out.println("");
}
return cntArr;
}
}
Analysis
expand all
Example tests
1.
0.012 s
WRONG ANSWER,
got [3, 0, 1, 1, 0] expected [3, 2, 2, 4, 2]
stdout:
0 0 1 0 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1 0 3 0 1 1 0 3 0 1 3 0 3 0 1 1 0
expand all
User tests
1.
0.012 s
OK
function result: [3, 0, 1, 5, 0]
function result: [3, 0, 1, 5, 0]
stdout:
0 0 1 0 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1 0 3 0 1 1 0 3 0 1 1 0 3 0 1 5 0
User test case 1:
[5, [3, 4, 4, 6, 1, 6, 4]]
Code: 10:12:51 UTC,
java,
verify,
result: Failed
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int tmpMax = 0;
int tmp = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
tmpMax = max+1;
}else{
if( tmpMax < cntArr[A[i]-1] ){
cntArr[A[i]-1]++;
}else{
cntArr[A[i]-1] = tmpMax + 1;
}
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
System.out.println("");
}
return cntArr;
}
}
Analysis
expand all
Example tests
1.
0.008 s
WRONG ANSWER,
got [4, 0, 1, 5, 0] expected [3, 2, 2, 4, 2]
stdout:
0 0 1 0 0 0 0 1 1 0 0 0 1 2 0 0 0 1 2 0 4 0 1 2 0 4 0 1 4 0 4 0 1 5 0
expand all
User tests
1.
0.004 s
OK
function result: [4, 0, 1, 6, 0]
function result: [4, 0, 1, 6, 0]
stdout:
0 0 1 0 0 0 0 1 1 0 0 0 1 2 0 0 0 1 2 0 4 0 1 2 0 4 0 1 2 0 4 0 1 6 0
User test case 1:
[5, [3, 4, 4, 6, 1, 6, 4]]
Code: 10:13:20 UTC,
java,
autosave
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int tmpMax = 0;
int tmp = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
tmpMax = max;
}else{
if( tmpMax < cntArr[A[i]-1] ){
cntArr[A[i]-1]++;
}else{
cntArr[A[i]-1] = tmpMax + 1;
}
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
System.out.println("");
}
return cntArr;
}
}
Code: 10:13:21 UTC,
java,
verify,
result: Failed
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int tmpMax = 0;
int tmp = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
tmpMax = max;
}else{
if( tmpMax < cntArr[A[i]-1] ){
cntArr[A[i]-1]++;
}else{
cntArr[A[i]-1] = tmpMax + 1;
}
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
System.out.println("");
}
return cntArr;
}
}
Analysis
expand all
Example tests
1.
0.012 s
WRONG ANSWER,
got [3, 0, 1, 4, 0] expected [3, 2, 2, 4, 2]
stdout:
0 0 1 0 0 0 0 1 1 0 0 0 1 2 0 0 0 1 2 0 3 0 1 2 0 3 0 1 3 0 3 0 1 4 0
expand all
User tests
1.
0.008 s
OK
function result: [3, 0, 1, 4, 0]
function result: [3, 0, 1, 4, 0]
stdout:
0 0 1 0 0 0 0 1 1 0 0 0 1 2 0 0 0 1 2 0 3 0 1 2 0 3 0 1 2 0 3 0 1 4 0
User test case 1:
[5, [3, 4, 4, 6, 1, 6, 4]]
Code: 10:13:37 UTC,
java,
autosave
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int tmpMax = 0;
int tmp = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
tmpMax = max;
}else{
if( tmpMax < cntArr[A[i]-1] ){
cntArr[A[i]-1]++;
}else{
cntArr[A[i]-1] = tmpMax + 1;
}
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
System.out.println("");
}
for()
return cntArr;
}
}
Code: 10:14:07 UTC,
java,
autosave
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int tmpMax = 0;
int tmp = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
tmpMax = max;
}else{
if( tmpMax < cntArr[A[i]-1] ){
cntArr[A[i]-1]++;
}else{
cntArr[A[i]-1] = tmpMax + 1;
}
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
System.out.println("");
}
for(int i=0;i<cntArr.length;i++){
if(cntArr[i])
}
return cntArr;
}
}
Code: 10:14:24 UTC,
java,
autosave
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int tmpMax = 0;
int tmp = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
tmpMax = max;
}else{
if( tmpMax < cntArr[A[i]-1] ){
cntArr[A[i]-1]++;
}else{
cntArr[A[i]-1] = tmpMax + 1;
}
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
System.out.println("");
}
for(int i=0;i<cntArr.length;i++){
if(cntArr[i] < tmpMax){
cntArr[i] = tmpMax;
}
}
return cntArr;
}
}
Code: 10:14:25 UTC,
java,
verify,
result: Passed
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int tmpMax = 0;
int tmp = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
tmpMax = max;
}else{
if( tmpMax < cntArr[A[i]-1] ){
cntArr[A[i]-1]++;
}else{
cntArr[A[i]-1] = tmpMax + 1;
}
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
for(int k=0;k<cntArr.length;k++){
System.out.print(cntArr[k] + " ");
}
System.out.println("");
}
for(int i=0;i<cntArr.length;i++){
if(cntArr[i] < tmpMax){
cntArr[i] = tmpMax;
}
}
return cntArr;
}
}
Analysis
expand all
Example tests
1.
0.012 s
OK
stdout:
0 0 1 0 0 0 0 1 1 0 0 0 1 2 0 0 0 1 2 0 3 0 1 2 0 3 0 1 3 0 3 0 1 4 0
expand all
User tests
1.
0.004 s
OK
function result: [3, 3, 3, 4, 3]
function result: [3, 3, 3, 4, 3]
stdout:
0 0 1 0 0 0 0 1 1 0 0 0 1 2 0 0 0 1 2 0 3 0 1 2 0 3 0 1 2 0 3 0 1 4 0
User test case 1:
[5, [3, 4, 4, 6, 1, 6, 4]]
Code: 10:14:59 UTC,
java,
autosave
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int tmpMax = 0;
int tmp = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
tmpMax = max;
}else{
if( tmpMax < cntArr[A[i]-1] ){
cntArr[A[i]-1]++;
}else{
cntArr[A[i]-1] = tmpMax + 1;
}
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
}
for(int i=0;i<cntArr.length;i++){
if(cntArr[i] < tmpMax){
cntArr[i] = tmpMax;
}
}
return cntArr;
}
}
Code: 10:15:13 UTC,
java,
verify,
result: Passed
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int tmpMax = 0;
int tmp = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
tmpMax = max;
}else{
if( tmpMax < cntArr[A[i]-1] ){
cntArr[A[i]-1]++;
}else{
cntArr[A[i]-1] = tmpMax + 1;
}
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
}
for(int i=0;i<cntArr.length;i++){
if(cntArr[i] < tmpMax){
cntArr[i] = tmpMax;
}
}
return cntArr;
}
}
Analysis
User test case 1:
[5, [3, 4, 4, 6, 1, 6, 4]]
Code: 10:15:19 UTC,
java,
final,
score:
100
class Solution {
public int[] solution(int N, int[] A) {
int [] cntArr = new int[N];
int max = 0;
int tmpMax = 0;
int tmp = 0;
for(int i=0; i<A.length; i++){
if(A[i] == N+1){
tmpMax = max;
}else{
if( tmpMax < cntArr[A[i]-1] ){
cntArr[A[i]-1]++;
}else{
cntArr[A[i]-1] = tmpMax + 1;
}
if( max < cntArr[A[i]-1] )
max = cntArr[A[i]-1];
}
}
for(int i=0;i<cntArr.length;i++){
if(cntArr[i] < tmpMax){
cntArr[i] = tmpMax;
}
}
return cntArr;
}
}Analysis summary
The solution obtained perfect score.
Analysis
Detected time complexity:
O(N + M)
expand all
Performance tests
1.
0.016 s
OK
1.
0.020 s
OK
1.
0.404 s
OK
1.
0.576 s
OK
1.
1.312 s
OK
2.
1.208 s
OK