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–2024 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Solution
Programming language used Java 8
Time spent on task 25 minutes
Notes
not defined yet
Task timeline
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;
}
}
User test case 1:
[5, [3, 4, 4, 6, 1, 6, 4]]
Analysis
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;
}
}
User test case 1:
[5, [3, 4, 4, 6, 1, 6, 4]]
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
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;
}
}
User test case 1:
[5, [3, 4, 4, 6, 1, 6, 4]]
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
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;
}
}
User test case 1:
[5, [3, 4, 4, 6, 1, 6, 4]]
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
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;
}
}
User test case 1:
[5, [3, 4, 4, 6, 1, 6, 4]]
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
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;
}
}
User test case 1:
[5, [3, 4, 4, 6, 1, 6, 4]]
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
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;
}
}
User test case 1:
[5, [3, 4, 4, 6, 1, 6, 4]]
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
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;
}
}
User test case 1:
[5, [3, 4, 4, 6, 1, 6, 4]]
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
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;
}
}
User test case 1:
[5, [3, 4, 4, 6, 1, 6, 4]]
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
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;
}
}
User test case 1:
[5, [3, 4, 4, 6, 1, 6, 4]]
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
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;
}
}
User test case 1:
[5, [3, 4, 4, 6, 1, 6, 4]]
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
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;
}
}
User test case 1:
[5, [3, 4, 4, 6, 1, 6, 4]]
Analysis
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