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:

vector<int> solution(int N, vector<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 a vector 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 C++

Time spent on task 9 minutes

Notes

not defined yet

Code: 05:35:38 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: 05:35: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

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> solution(int N, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    vector<int> counter(N,0);
    int max_counter = 0;

    //시간복잡도 N
    for(int i = 0; i<A.size(); i++){
        if(A[i] >=1 && A[i] <= N){
            counter[A[i]-1] ++;
            max_counter = max(max_counter, counter[A[i]-1]);
        }
        else if(A[i] == N+1){
            //시간복잡도 N
            fill_n(counter.begin(), N, max_counter);
        }
    }
    
    //시간복잡도 N^2 => 10000000000

    return counter;

}

Code: 05:36: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 23 24 25 26 27 28 29

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> solution(int N, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    vector<int> counter(N,0);
    int max_counter = 0;

    //시간복잡도 N
    for(int i = 0; i<A.size(); i++){
        
        if(A[i] >=1 && A[i] <= N){
            counter[A[i]-1] ++;
            max_counter = max(max_counter, counter[A[i]-1]);
        }
        else if(A[i] == N+1){
            //시간복잡도 N
            fill_n(counter.begin(), N, max_counter);
        }
    }
    
    //시간복잡도 N^2 => 10000000000

    return counter;

}

Code: 05:36: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

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> solution(int N, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    vector<int> counter(N,0);
    int max_counter = 0;

    //시간복잡도 N
    for(int i = 0; i<A.size(); i++){
        if(A[i] == N+1){
            
        }
        if(A[i] >=1 && A[i] <= N){
            counter[A[i]-1] ++;
            max_counter = max(max_counter, counter[A[i]-1]);
        }
        else if(A[i] == N+1){
            //시간복잡도 N
            fill_n(counter.begin(), N, max_counter);
        }
    }
    
    //시간복잡도 N^2 => 10000000000

    return counter;

}

Code: 05:36: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

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> solution(int N, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    vector<int> counter(N,0);
    int max_counter = 0;

    //시간복잡도 N
    for(int i = 0; i<A.size(); i++){
        if(A[i] == N+1){
            counter[A[i]-1] = 
        }
        if(A[i] >=1 && A[i] <= N){
            counter[A[i]-1] ++;
            max_counter = max(max_counter, counter[A[i]-1]);
        }
        else if(A[i] == N+1){
            //시간복잡도 N
            fill_n(counter.begin(), N, max_counter);
        }
    }
    
    //시간복잡도 N^2 => 10000000000

    return counter;

}

Code: 05:37: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 23 24 25 26 27 28 29 30 31 32 33

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> solution(int N, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    vector<int> counter(N,0);
    int max_counter = 0;

    //시간복잡도 N
    for(int i = 0; i<A.size(); i++){
        if(A[i] == N+1){
            counter[A[i]-1] = max_counter;
        }else{
            
        }
        if(A[i] >=1 && A[i] <= N){
            counter[A[i]-1] ++;
            max_counter = max(max_counter, counter[A[i]-1]);
        }
        else if(A[i] == N+1){
            //시간복잡도 N
            fill_n(counter.begin(), N, max_counter);
        }
    }
    
    //시간복잡도 N^2 => 10000000000

    return counter;

}

Code: 05:37: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

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> solution(int N, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    vector<int> counter(N,0);
    int max_counter = 0;

    //시간복잡도 N
    for(int i = 0; i<A.size(); i++){
        if(A[i] == N+1){
            counter[A[i]-1] = max_counter;
        }else{
            if(A[i] >=1 && A[i] <= N){
                counter[A[i]-1] ++;
                max_counter = max(max_counter, counter[A[i]-1]);
            }   
        }

    }
    
    //시간복잡도 N^2 => 10000000000

    return counter;

}

Code: 05:38: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

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> solution(int N, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    vector<int> counter(N,0);
    int max_counter = 0;

    //시간복잡도 N
    for(int i = 0; i<A.size(); i++){
        if(A[i] == N+1){
            counter[A[i]-1] = max_counter;
        }else{
            if(A[i] >=1 && A[i] <= N){
                if(counter[A[i]-1] < max_counter) counter[A[i]-1] =ma
                counter[A[i]-1] ++;
                max_counter = max(max_counter, counter[A[i]-1]);
            }   
        }

    }
    
    //시간복잡도 N^2 => 10000000000

    return counter;

}

Code: 05:38: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 32 33

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> solution(int N, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    vector<int> counter(N,0);
    int max_counter = 0;

    //시간복잡도 N
    for(int i = 0; i<A.size(); i++){
        if(A[i] == N+1){
            counter[A[i]-1] = max_counter;
        }else{
            if(A[i] >=1 && A[i] <= N){
                if(counter[A[i]-1] < max_counter) counter[A[i]-1] = max_counter+1;
                else{
                    
                }
                counter[A[i]-1] ++;
                max_counter = max(max_counter, counter[A[i]-1]);
            }   
        }

    }
    
    //시간복잡도 N^2 => 10000000000

    return counter;

}

Code: 05:38: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 29 30 31 32 33

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> solution(int N, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    vector<int> counter(N,0);
    int max_counter = 0;

    //시간복잡도 N
    for(int i = 0; i<A.size(); i++){
        if(A[i] == N+1){
            counter[A[i]-1] = max_counter;
        }else{
            if(A[i] >=1 && A[i] <= N){
                if(counter[A[i]-1] < max_counter) counter[A[i]-1] = max_counter+1;
                else{
                    counter[A[i]-1] ++;
                    max_counter = max(max_counter, counter[A[i]-1]);
                }
                
            }   
        }

    }
    
    //시간복잡도 N^2 => 10000000000

    return counter;

}

Code: 05:38: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

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> solution(int N, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    vector<int> counter(N,0);
    int max_counter = 0;

    //시간복잡도 N
    for(int i = 0; i<A.size(); i++){
        if(A[i] == N+1){
            counter[A[i]-1] = max_counter;
        }else{
            if(A[i] >=1 && A[i] <= N){
                if(counter[A[i]-1] < max_counter) counter[A[i]-1] = max_counter+1;
                else counter[A[i]-1] ++;
                    
                max_counter = max(max_counter, counter[A[i]-1]);
            }   
        }

    }
    
    //시간복잡도 N^2 => 10000000000

    return counter;

}

Code: 05:40:40 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

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> solution(int N, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    vector<int> counter(N,0);
    int max_counter = 0;
    
    //시간복잡도 N
    for(int i = 0; i<A.size(); i++){
        if(A[i] == N+1){
            counter[A[i]-1] = max_counter;
        }else{
            if(A[i] >=1 && A[i] <= N){
                if(counter[A[i]-1] < max_counter) counter[A[i]-1] = max_counter+1;
                else counter[A[i]-1] ++;
                    
                max_counter = max(max_counter, counter[A[i]-1]);
            }   
        }

    }
    
    //시간복잡도 N^2 => 10000000000

    return counter;

}

Code: 05:40: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

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> solution(int N, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    vector<int> counter(N,0);
    int max_counter = 0;
    int last_max_counter = 0;
    
    //시간복잡도 N
    for(int i = 0; i<A.size(); i++){
        if(A[i] == N+1){
            counter[A[i]-1] = max_counter;
        }else{
            if(A[i] >=1 && A[i] <= N){
                if(counter[A[i]-1] < max_counter) counter[A[i]-1] = max_counter+1;
                else counter[A[i]-1] ++;
                    
                max_counter = max(max_counter, counter[A[i]-1]);
            }   
        }

    }
    
    //시간복잡도 N^2 => 10000000000

    return counter;

}

Code: 05:41:03 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

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> solution(int N, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    vector<int> counter(N,0);
    int max_counter = 0;
    int last_max_counter = 0;

    //시간복잡도 N
    for(int i = 0; i<A.size(); i++){
        if(A[i] == N+1){
            last_max_counter = max_counter;
        }else{
            if(A[i] >=1 && A[i] <= N){
                if(counter[A[i]-1] < max_counter) counter[A[i]-1] = max_counter+1;
                else counter[A[i]-1] ++;
                    
                max_counter = max(max_counter, counter[A[i]-1]);
            }   
        }

    }
    
    //시간복잡도 N^2 => 10000000000

    return counter;

}

Code: 05:41:17 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

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> solution(int N, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    vector<int> counter(N,0);
    int max_counter = 0;
    int last_max_counter = 0;

    //시간복잡도 N
    for(int i = 0; i<A.size(); i++){
        if(A[i] == N+1){
            last_max_counter = max_counter;
        }else{
            if(A[i] >=1 && A[i] <= N){
                if(counter[A[i]-1] < last_max_counter) counter[A[i]-1] = last_max_counter+1;
                else counter[A[i]-1] ++;
                    
                max_counter = max(max_counter, counter[A[i]-1]);
            }   
        }

    }
    
    //시간복잡도 N^2 => 10000000000

    return counter;

}

Code: 05:41: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

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> solution(int N, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    vector<int> counter(N,0);
    int max_counter = 0;
    int last_max_counter = 0;

    //시간복잡도 N
    for(int i = 0; i<A.size(); i++){
        if(A[i] == N+1){
            last_max_counter = max_counter;
        }else{
            if(A[i] >=1 && A[i] <= N){
                if(counter[A[i]-1] < last_max_counter) counter[A[i]-1] = last_max_counter+1;
                else counter[A[i]-1] ++;
                    
                max_counter = max(max_counter, counter[A[i]-1]);
            }   
        }
    }

    for(int i =0; i<counter.size(); i++){
        if(counter[i] )
    }
    
    //시간복잡도 N^2 => 10000000000

    return counter;

}

Code: 05:41: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 35 36 37

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> solution(int N, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    vector<int> counter(N,0);
    int max_counter = 0;
    int last_max_counter = 0;

    //시간복잡도 N
    for(int i = 0; i<A.size(); i++){
        if(A[i] == N+1){
            last_max_counter = max_counter;
        }else{
            if(A[i] >=1 && A[i] <= N){
                if(counter[A[i]-1] < last_max_counter) counter[A[i]-1] = last_max_counter+1;
                else counter[A[i]-1] ++;
                    
                max_counter = max(max_counter, counter[A[i]-1]);
            }   
        }
    }

    for(int i =0; i<counter.size(); i++){
        if(counter[i] < last_max_counter){
            
        }
    }
    
    //시간복잡도 N^2 => 10000000000

    return counter;

}

Code: 05:42:09 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

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> solution(int N, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    vector<int> counter(N,0);
    int max_counter = 0;
    int last_max_counter = 0;

    //시간복잡도 N
    for(int i = 0; i<A.size(); i++){
        if(A[i] == N+1){
            last_max_counter = max_counter;
        }else{
            if(A[i] >=1 && A[i] <= N){
                if(counter[A[i]-1] < last_max_counter) counter[A[i]-1] = last_max_counter+1;
                else counter[A[i]-1] ++;
                    
                max_counter = max(max_counter, counter[A[i]-1]);
            }   
        }
    }

    for(int i =0; i<counter.size(); i++){
        if(counter[i] < last_max_counter){
            counter[i] = last_max_counter;
        }
    }
    
    //시간복잡도 N^2 => 10000000000

    return counter;

}

Code: 05:42:16 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

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> solution(int N, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    vector<int> counter(N,0);
    int max_counter = 0;
    int last_max_counter = 0;

    //시간복잡도 N
    for(int i = 0; i<A.size(); i++){
        if(A[i] == N+1){
            last_max_counter = max_counter;
        }else{
            if(A[i] >=1 && A[i] <= N){
                if(counter[A[i]-1] < last_max_counter) counter[A[i]-1] = last_max_counter+1;
                else counter[A[i]-1] ++;
                    
                max_counter = max(max_counter, counter[A[i]-1]);
            }   
        }
    }

    for(int i =0; i<counter.size(); i++){
        if(counter[i] < last_max_counter){
            counter[i] = last_max_counter;
        }
    }
    
    return counter;

}

Analysis

Compile error

Solution.java:1: error: illegal character: '#'
#include <iostream>
^
Solution.java:1: error: class, interface, or enum expected
#include <iostream>
         ^
Solution.java:2: error: illegal character: '#'
#include <vector>
^
Solution.java:3: error: illegal character: '#'
#include <algorithm>
^
Solution.java:6: error: class, interface, or enum expected
vector<int> solution(int N, vector<int> &A) {
^
Solution.java:10: error: class, interface, or enum expected
    int max_counter = 0;
    ^
Solution.java:11: error: class, interface, or enum expected
    int last_max_counter = 0;
    ^
Solution.java:14: error: class, interface, or enum expected
    for(int i = 0; i<A.size(); i++){
    ^
Solution.java:14: error: class, interface, or enum expected
    for(int i = 0; i<A.size(); i++){
                   ^
Solution.java:14: error: class, interface, or enum expected
    for(int i = 0; i<A.size(); i++){
                               ^
Solution.java:17: error: class, interface, or enum expected
        }else{
        ^
Solution.java:20: error: class, interface, or enum expected
                else counter[A[i]-1] ++;
                ^
Solution.java:22: error: class, interface, or enum expected
                max_counter = max(max_counter, counter[A[i]-1]);
                ^
Solution.java:23: error: class, interface, or enum expected
            }   
            ^
Solution.java:27: error: class, interface, or enum expected
    for(int i =0; i<counter.size(); i++){
                  ^
Solution.java:27: error: class, interface, or enum expected
    for(int i =0; i<counter.size(); i++){
                                    ^
Solution.java:30: error: class, interface, or enum expected
        }
        ^
Solution.java:35: error: class, interface, or enum expected
}
^
18 errors

Code: 05:42:40 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

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;



vector<int> solution(int N, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    vector<int> counter(N,0);
    int max_counter = 0;
    int last_max_counter = 0;

    //시간복잡도 N
    for(int i = 0; i<A.size(); i++){
        if(A[i] == N+1){
            last_max_counter = max_counter;
        }else{
            if(A[i] >=1 && A[i] <= N){
                if(counter[A[i]-1] < last_max_counter) counter[A[i]-1] = last_max_counter+1;
                else counter[A[i]-1] ++;
                    
                max_counter = max(max_counter, counter[A[i]-1]);
            }   
        }
    }

    for(int i =0; i<counter.size(); i++){
        if(counter[i] < last_max_counter){
            counter[i] = last_max_counter;
        }
    }
    
    return counter;

}

Code: 05:43: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



using namespace std;

vector<int> solution(int N, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    vector<int> counter(N,0);
    int max_counter = 0;
    int last_max_counter = 0;

    //시간복잡도 N
    for(int i = 0; i<A.size(); i++){
        if(A[i] == N+1){
            last_max_counter = max_counter;
        }else{
            if(A[i] >=1 && A[i] <= N){
                if(counter[A[i]-1] < last_max_counter) counter[A[i]-1] = last_max_counter+1;
                else counter[A[i]-1] ++;
                    
                max_counter = max(max_counter, counter[A[i]-1]);
            }   
        }
    }

    for(int i =0; i<counter.size(); i++){
        if(counter[i] < last_max_counter){
            counter[i] = last_max_counter;
        }
    }
    
    return counter;

}

Code: 05:43:20 UTC, cpp, 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



using namespace std;

vector<int> solution(int N, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    vector<int> counter(N,0);
    int max_counter = 0;
    int last_max_counter = 0;

    //시간복잡도 N
    for(int i = 0; i<A.size(); i++){
        if(A[i] == N+1){
            last_max_counter = max_counter;
        }else{
            if(A[i] >=1 && A[i] <= N){
                if(counter[A[i]-1] < last_max_counter) counter[A[i]-1] = last_max_counter+1;
                else counter[A[i]-1] ++;
                    
                max_counter = max(max_counter, counter[A[i]-1]);
            }   
        }
    }

    for(int i =0; i<counter.size(); i++){
        if(counter[i] < last_max_counter){
            counter[i] = last_max_counter;
        }
    }
    
    return counter;

}

Code: 05:43:34 UTC, cpp, 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

#include <iostream>
#include <vector>
#include <

using namespace std;

vector<int> solution(int N, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    vector<int> counter(N,0);
    int max_counter = 0;
    int last_max_counter = 0;

    //시간복잡도 N
    for(int i = 0; i<A.size(); i++){
        if(A[i] == N+1){
            last_max_counter = max_counter;
        }else{
            if(A[i] >=1 && A[i] <= N){
                if(counter[A[i]-1] < last_max_counter) counter[A[i]-1] = last_max_counter+1;
                else counter[A[i]-1] ++;
                    
                max_counter = max(max_counter, counter[A[i]-1]);
            }   
        }
    }

    for(int i =0; i<counter.size(); i++){
        if(counter[i] < last_max_counter){
            counter[i] = last_max_counter;
        }
    }
    
    return counter;

}

Code: 05:43:45 UTC, cpp, 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

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> solution(int N, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    vector<int> counter(N,0);
    int max_counter = 0;
    int last_max_counter = 0;

    //시간복잡도 N
    for(int i = 0; i<A.size(); i++){
        if(A[i] == N+1){
            last_max_counter = max_counter;
        }else{
            if(A[i] >=1 && A[i] <= N){
                if(counter[A[i]-1] < last_max_counter) counter[A[i]-1] = last_max_counter+1;
                else counter[A[i]-1] ++;
                    
                max_counter = max(max_counter, counter[A[i]-1]);
            }   
        }
    }

    for(int i =0; i<counter.size(); i++){
        if(counter[i] < last_max_counter){
            counter[i] = last_max_counter;
        }
    }
    
    return counter;

}

Analysis

expand all Example tests

▶

example
example test

✔

0.001 s

Code: 05:43:53 UTC, cpp, 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

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> solution(int N, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    vector<int> counter(N,0);
    int max_counter = 0;
    int last_max_counter = 0;

    //시간복잡도 N
    for(int i = 0; i<A.size(); i++){
        if(A[i] == N+1){
            last_max_counter = max_counter;
        }else{
            if(A[i] >=1 && A[i] <= N){
                if(counter[A[i]-1] < last_max_counter) counter[A[i]-1] = last_max_counter+1;
                else counter[A[i]-1] ++;
                    
                max_counter = max(max_counter, counter[A[i]-1]);
            }   
        }
    }

    for(int i =0; i<counter.size(); i++){
        if(counter[i] < last_max_counter){
            counter[i] = last_max_counter;
        }
    }
    
    return counter;

}

Analysis

expand all Example tests

▶

example
example test

✔

0.001 s

Code: 05:43:56 UTC, cpp, 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 35

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> solution(int N, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    vector<int> counter(N,0);
    int max_counter = 0;
    int last_max_counter = 0;

    //시간복잡도 N
    for(int i = 0; i<A.size(); i++){
        if(A[i] == N+1){
            last_max_counter = max_counter;
        }else{
            if(A[i] >=1 && A[i] <= N){
                if(counter[A[i]-1] < last_max_counter) counter[A[i]-1] = last_max_counter+1;
                else counter[A[i]-1] ++;
                    
                max_counter = max(max_counter, counter[A[i]-1]);
            }   
        }
    }

    for(int i =0; i<counter.size(); i++){
        if(counter[i] < last_max_counter){
            counter[i] = last_max_counter;
        }
    }
    
    return counter;

}

Analysis summary

The solution obtained perfect score.

Analysis

Detected time complexity:

O(N + M)

expand all Example tests

▶

example
example test

✔

0.001 s

expand all Correctness tests

▶

extreme_small
all max_counter operations

✔

0.001 s

▶

single
only one counter

✔

0.001 s

▶

small_random1
small random test, 6 max_counter operations

✔

0.001 s

▶

small_random2
small random test, 10 max_counter operations

✔

0.001 s

expand all Performance tests

▶

medium_random1
medium random test, 50 max_counter operations

✔

0.001 s

▶

medium_random2
medium random test, 500 max_counter operations

✔

0.001 s

▶

large_random1
large random test, 2120 max_counter operations

✔

0.004 s

▶

large_random2
large random test, 10000 max_counter operations

✔

0.008 s

▶

extreme_large
all max_counter operations

✔

0.016 s

0.012 s