Tasks Details
**Task Score**
**Correctness**
**Performance**
` A[0] = 3
A[1] = 4
A[2] = 4
A[3] = 6
A[4] = 1
A[5] = 4
A[6] = 4`
` (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)`
` A[0] = 3
A[1] = 4
A[2] = 4
A[3] = 6
A[4] = 1
A[5] = 4
A[6] = 4`
**OK**

function result: [0, 0, 0, 0, 0]
**OK**

function result: [17, 0, 0, 0, 0, 0]
**OK**

function result: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
**OK**

function result: [0, 0, 0, 0, 0]
**OK**

function result: [17, 0, 0, 0, 0, 0]
**OK**

function result: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
**OK**

function result: [0, 0, 0, 0, 0]
**OK**

function result: [17, 0, 0, 0, 0, 0]
**OK**

function result: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
**
O(N + M)
**
**OK**
**OK**
**OK**
**OK**
**OK**
**OK**

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.
100%

100%

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:

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

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

Write a function:

def solution(N, 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:

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].

Copyright 2009–2020 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.

Solution

Programming language used Python

Total time used 2 minutes

Effective time used 2 minutes

Notes
*not defined yet*

Task timeline

Code: 02:28:06 UTC,
py,
verify,
result: **Passed**

```
# you can write to stdout for debugging purposes, e.g.
# print "this is a debug message"
def solution(N, A):
# write your code in Python 2.7
rmin = 0
rmax = 0
C = [0] * N
M = len(A)
if not M:
return C
for i in range(M):
X = A[i]
if X <= N:
X = X - 1
c = C[X]
if c < rmin:
c = rmin + 1
else:
c = c + 1
rmax = max(rmax, c)
C[X] = c
elif X == N+1:
rmin = rmax
print C
for i in range(N):
if C[i] < rmin:
C[i] = rmin
return C
```

User test case 1:

[5, []]

User test case 2:

[6, [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]

User test case 3:

[10, [11, 11, 11, 11]]

Analysis

expand all
**User tests**

1.

0.068 s

function result: [0, 0, 0, 0, 0]

1.

0.070 s

function result: [17, 0, 0, 0, 0, 0]

stdout:

[17, 0, 0, 0, 0, 0]

1.

0.069 s

function result: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

stdout:

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

Code: 02:28:15 UTC,
py,
verify,
result: **Passed**

```
# you can write to stdout for debugging purposes, e.g.
# print "this is a debug message"
def solution(N, A):
# write your code in Python 2.7
rmin = 0
rmax = 0
C = [0] * N
M = len(A)
if not M:
return C
for i in range(M):
X = A[i]
if X <= N:
X = X - 1
c = C[X]
if c < rmin:
c = rmin + 1
else:
c = c + 1
rmax = max(rmax, c)
C[X] = c
elif X == N+1:
rmin = rmax
for i in range(N):
if C[i] < rmin:
C[i] = rmin
return C
```

User test case 1:

[5, []]

User test case 2:

[6, [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]

User test case 3:

[10, [11, 11, 11, 11]]

Analysis

expand all
**User tests**

1.

0.069 s

function result: [0, 0, 0, 0, 0]

1.

0.070 s

function result: [17, 0, 0, 0, 0, 0]

1.

0.069 s

function result: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

Code: 02:28:33 UTC,
py,
verify,
result: **Passed**

```
# you can write to stdout for debugging purposes, e.g.
# print "this is a debug message"
def solution(N, A):
# write your code in Python 2.7
rmin = 0
rmax = 0
C = [0] * N
M = len(A)
if not M:
return C
for i in range(M):
X = A[i]
if X <= N:
X = X - 1
c = C[X]
if c < rmin:
c = rmin + 1
else:
c = c + 1
rmax = max(rmax, c)
C[X] = c
elif X == N+1:
rmin = rmax
for i in range(N):
if C[i] < rmin:
C[i] = rmin
return C
```

User test case 1:

[5, []]

User test case 2:

[6, [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]

User test case 3:

[10, [11, 11, 11, 11]]

Analysis

expand all
**User tests**

1.

0.066 s

function result: [0, 0, 0, 0, 0]

1.

0.068 s

function result: [17, 0, 0, 0, 0, 0]

1.

0.070 s

function result: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

Code: 02:28:35 UTC,
py,
final,
score: **
100
**

```
# you can write to stdout for debugging purposes, e.g.
# print "this is a debug message"
def solution(N, A):
# write your code in Python 2.7
rmin = 0
rmax = 0
C = [0] * N
M = len(A)
if not M:
return C
for i in range(M):
X = A[i]
if X <= N:
X = X - 1
c = C[X]
if c < rmin:
c = rmin + 1
else:
c = c + 1
rmax = max(rmax, c)
C[X] = c
elif X == N+1:
rmin = rmax
for i in range(N):
if C[i] < rmin:
C[i] = rmin
return C
```

Analysis summary

The solution obtained perfect score.

Analysis

Detected time complexity:

expand all
**Performance tests**

1.

0.069 s

1.

0.066 s

1.

0.133 s

1.

0.210 s

1.

0.259 s

2.

0.260 s

PDF version of this report that may be downloaded on top of this site may contain sensitive data including personal information. For security purposes, we recommend you remove it from your system once reviewed.