Tasks Details
hard
Given an array, find all its elements that can become a leader, after increasing by 1 all of the numbers in some segment of a given length.
Task Score
55%
Correctness
100%
Performance
0%
Integers K, M and a non-empty array A consisting of N integers, not bigger than M, are given.
The leader of the array is a value that occurs in more than half of the elements of the array, and the segment of the array is a sequence of consecutive elements of the array.
You can modify A by choosing exactly one segment of length K and increasing by 1 every element within that segment.
The goal is to find all of the numbers that may become a leader after performing exactly one array modification as described above.
Write a function:
def solution(K, M, A)
that, given integers K and M and an array A consisting of N integers, returns an array of all numbers that can become a leader, after increasing by 1 every element of exactly one segment of A of length K. The returned array should be sorted in ascending order, and if there is no number that can become a leader, you should return an empty array. Moreover, if there are multiple ways of choosing a segment to turn some number into a leader, then this particular number should appear in an output array only once.
For example, given integers K = 3, M = 5 and the following array A:
A[0] = 2 A[1] = 1 A[2] = 3 A[3] = 1 A[4] = 2 A[5] = 2 A[6] = 3the function should return [2, 3]. If we choose segment A[1], A[2], A[3] then we get the following array A:
A[0] = 2 A[1] = 2 A[2] = 4 A[3] = 2 A[4] = 2 A[5] = 2 A[6] = 3and 2 is the leader of this array. If we choose A[3], A[4], A[5] then A will appear as follows:
A[0] = 2 A[1] = 1 A[2] = 3 A[3] = 2 A[4] = 3 A[5] = 3 A[6] = 3and 3 will be the leader.
And, for example, given integers K = 4, M = 2 and the following array:
A[0] = 1 A[1] = 2 A[2] = 2 A[3] = 1 A[4] = 2the function should return [2, 3], because choosing a segment A[0], A[1], A[2], A[3] and A[1], A[2], A[3], A[4] turns 2 and 3 into the leaders, respectively.
Write an efficient algorithm for the following assumptions:
- N and M are integers within the range [1..100,000];
- K is an integer within the range [1..N];
- each element of array A is an integer within the range [1..M].
Copyright 2009–2025 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Solution
Programming language used Python
Time spent on task 45 minutes
Notes
not defined yet
Code: 17:04:39 UTC,
java,
autosave
Code: 17:06:28 UTC,
py,
autosave
Code: 17:07:17 UTC,
py,
autosave
Code: 17:07:34 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count < N/2:
leader = element
def solution(K, M, A):
# write your code in Python 3.6
pass
Code: 17:07:48 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > N/2:
leader = element
return leader
def solution(K, M, A):
# write your code in Python 3.6
pass
Code: 17:08:19 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > N/2:
leader = element
return leader
def solution(K, M, A):
# write your code in Python 3.6
pass
Code: 17:08:33 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > N/2:
leader = element
return leader
def increment_segment(A,
def solution(K, M, A):
# write your code in Python 3.6
pass
Code: 17:08:57 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > N/2:
leader = element
return leader
def increment_segment(A, K,
def solution(K, M, A):
# write your code in Python 3.6
pass
Code: 17:09:27 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
def solution(K, M, A):
# write your code in Python 3.6
pass
Code: 17:09:48 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
for x in B
def solution(K, M, A):
# write your code in Python 3.6
pass
Code: 17:10:04 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
for x in B:
x = x + 1
def solution(K, M, A):
# write your code in Python 3.6
pass
Code: 17:10:24 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
for x in B:
x = x + 1
A[start_index:start_index + K] = B
def solution(K, M, A):
# write your code in Python 3.6
pass
Code: 17:10:54 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
for i in range(0, K
A[start_index:start_index + K] = B
def solution(K, M, A):
# write your code in Python 3.6
pass
Code: 17:11:16 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
for i in range(0, len(B)):
B[i] = B[i] + 1
A[start_index:start_index + K] = B
def solution(K, M, A):
# write your code in Python 3.6
pass
Code: 17:11:40 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
for i in range(0, len(B)):
B[i] = B[i] + 1
A[start_index:start_index + K] = B
def solution(K, M, A):
Code: 17:12:10 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
for i in range(0, len(B)):
B[i] = B[i] + 1
A[start_index:start_index + K] = B
def solution(K, M, A):
N = len(A)
A_c = copy(A)
leaders = set()
Code: 17:12:30 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
for i in range(0, len(B)):
B[i] = B[i] + 1
A[start_index:start_index + K] = B
def solution(K, M, A):
N = len(A)
A_c = copy(A)
leaders = set()
for i in range(0, len(A) - K + 1
Code: 17:12:40 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
for i in range(0, len(B)):
B[i] = B[i] + 1
A[start_index:start_index + K] = B
def solution(K, M, A):
A_c = copy(A)
leaders = set()
for i in range(0, len(A) - K + 1):
Code: 17:12:52 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
for i in range(0, len(B)):
B[i] = B[i] + 1
A[start_index:start_index + K] = B
def solution(K, M, A):
A_c = copy(A)
leaders = set()
for i in range(0, len(A) - K + 1):
A = copy(A_c)
Code: 17:13:11 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
for i in range(0, len(B)):
B[i] = B[i] + 1
A[start_index:start_index + K] = B
def solution(K, M, A):
leaders = set()
for i in range(0, len(A) - K + 1):
A_c = copy(A)
Code: 17:13:41 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
for i in range(0, len(B)):
B[i] = B[i] + 1
A[start_index:start_index + K] = B
def solution(K, M, A):
leaders = set()
for i in range(0, len(A) - K + 1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A)
if
Code: 17:14:12 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
for i in range(0, len(B)):
B[i] = B[i] + 1
A[start_index:start_index + K] = B
def solution(K, M, A):
leaders = set()
for i in range(0, len(A) - K):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
leaders_list =
return so
Code: 17:14:31 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
for i in range(0, len(B)):
B[i] = B[i] + 1
A[start_index:start_index + K] = B
def solution(K, M, A):
leaders = set()
for i in range(0, len(A) - K):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Code: 17:14:45 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
for i in range(0, len(B)):
B[i] = B[i] + 1
A[start_index:start_index + K] = B
def solution(K, M, A):
leaders = set()
for i in range(0, len(A) - K):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Analysis
expand all
Example tests
1.
0.040 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 149, in <module>
main()
File "exec.py", line 111, in main
result = solution( K, M, A )
File "/tmp/solution.py", line 27, in solution
leader = get_leader(A)
File "/tmp/solution.py", line 10, in get_leader
if count > N/2:
NameError: name 'N' is not defined
1.
0.040 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 149, in <module>
main()
File "exec.py", line 111, in main
result = solution( K, M, A )
File "/tmp/solution.py", line 27, in solution
leader = get_leader(A)
File "/tmp/solution.py", line 10, in get_leader
if count > N/2:
NameError: name 'N' is not defined
Code: 17:15:10 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > le/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
for i in range(0, len(B)):
B[i] = B[i] + 1
A[start_index:start_index + K] = B
def solution(K, M, A):
leaders = set()
for i in range(0, len(A) - K):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Code: 17:15:18 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > len(A)/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
for i in range(0, len(B)):
B[i] = B[i] + 1
A[start_index:start_index + K] = B
def solution(K, M, A):
leaders = set()
for i in range(0, len(A) - K):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Analysis
expand all
Example tests
1.
0.036 s
WRONG ANSWER,
got [] expected [2, 3]
1.
0.036 s
WRONG ANSWER,
got [2] expected [2, 3]
Code: 17:15:27 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > len(A)/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
for i in range(0, len(B)):
B[i] = B[i] + 1
A[start_index:start_index + K] = B
def solution(K, M, A):
leaders = set()
for i in range(0, len(A) - K + 1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Analysis
expand all
Example tests
1.
0.040 s
WRONG ANSWER,
got [] expected [2, 3]
1.
0.036 s
WRONG ANSWER,
got [2] expected [2, 3]
Code: 17:16:06 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > len(A)/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
for i in range(0, len(B)):
B[i] = B[i] + 1
A[start_index:start_index + K] = B
def solution(K, M, A):
leaders = set()
N
for i in range(0, len(A) - K + 1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Code: 17:16:17 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > len(A)/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
for i in range(0, len(B)):
B[i] = B[i] + 1
A[start_index:start_index + K] = B
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N - K + 1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Code: 17:16:27 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > len(A)/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
for i in range(0, len(B)):
B[i] = B[i] + 1
A[start_index:start_index + K] = B
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Code: 17:16:53 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > len(A)/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
for i in range(0, len(B)):
B[i] = B[i] + 1
A[start_index:start_index + K] = B
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Analysis
expand all
Example tests
1.
0.040 s
WRONG ANSWER,
got [] expected [2, 3]
1.
0.040 s
WRONG ANSWER,
got [2] expected [2, 3]
Code: 17:17:11 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > len(A)/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
A[start_index:start_index + K] = B
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Code: 17:17:20 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > len(A)/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index + K] = B
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Code: 17:17:30 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > len(A)/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index + K] = B
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Code: 17:17:39 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > len(A)/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Code: 17:17:42 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > len(A)/2:
leader = element
return leader
def increment_segment(A, K, start_index):
print(
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Code: 17:17:58 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > len(A)/2:
leader = element
return leader
def increment_segment(A, K, start_index):
print("Start_index = {}".format(start_index)
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Code: 17:17:59 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > len(A)/2:
leader = element
return leader
def increment_segment(A, K, start_index):
print("Start_index = {}".format(start_index)
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Analysis
expand all
Example tests
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 149, in <module>
main()
File "exec.py", line 90, in main
sol = __import__('solution')
File "/tmp/solution.py", line 16
B = A[start_index:start_index + K]
^
SyntaxError: invalid syntax
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 149, in <module>
main()
File "exec.py", line 90, in main
sol = __import__('solution')
File "/tmp/solution.py", line 16
B = A[start_index:start_index + K]
^
SyntaxError: invalid syntax
Code: 17:18:23 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > len(A)/2:
leader = element
return leader
def increment_segment(A, K, start_index):
print("Start_index = {}".format(start_index)(
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Code: 17:18:26 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > len(A)/2:
leader = element
return leader
def increment_segment(A, K, start_index):
print("Start_index = {}".format(start_index))
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Analysis
expand all
Example tests
1.
0.060 s
WRONG ANSWER,
got [] expected [2, 3]
stdout:
Start_index = 0 Start_index = 1 Start_index = 2 Start_index = 3 Start_index = 4
1.
0.056 s
WRONG ANSWER,
got [2] expected [2, 3]
stdout:
Start_index = 0 Start_index = 1
Code: 17:18:53 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > len(A)/2:
leader = element
return leader
def increment_segment(A, K, start_index):
print("Start_index = {}".format(start_index))
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Code: 17:19:24 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
print("Array: {}, leader:".format(A, leader)
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > len(A)/2:
leader = element
return leader
def increment_segment(A, K, start_index):
print("Start_index = {}".format(start_index))
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Code: 17:19:31 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > len(A)/2:
leader = element
print("Array: {}, leader: {}".format(A, leader))
return leader
def increment_segment(A, K, start_index):
print("Start_index = {}".format(start_index))
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Code: 17:19:32 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > len(A)/2:
leader = element
print("Array: {}, leader: {}".format(A, leader))
return leader
def increment_segment(A, K, start_index):
print("Start_index = {}".format(start_index))
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Analysis
expand all
Example tests
1.
0.036 s
WRONG ANSWER,
got [] expected [2, 3]
stdout:
Start_index = 0 Array: [2, 1, 3, 1, 2, 2, 3], leader: None Start_index = 1 Array: [2, 1, 3, 1, 2, 2, 3], leader: None Start_index = 2 Array: [2, 1, 3, 1, 2, 2, 3], leader: None Start_index = 3 Array: [2, 1, 3, 1, 2, 2, 3], leader: None Start_index = 4 Array: [2, 1, 3, 1, 2, 2, 3], leader: None
1.
0.036 s
WRONG ANSWER,
got [2] expected [2, 3]
stdout:
Start_index = 0 Array: [1, 2, 2, 1, 2], leader: 2 Start_index = 1 Array: [1, 2, 2, 1, 2], leader: 2
Code: 17:20:12 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
if count > len(A)/2:
leader = element
print("Array: {}, leader: {}".format(A, leader))
return leader
def increment_segment(A, K, start_index):
print("Start_index = {}".format(start_index))
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Code: 17:20:24 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
print("Array: {}, leader: {}".format(A, leader))
return leader
def increment_segment(A, K, start_index):
print("Start_index = {}".format(start_index))
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Code: 17:21:01 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
print("Array: {}, leader: {}".format(A, leader))
return leader
def increment_segment(A, K, start_index):
print("Start_index = {}".format(start_index))
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Analysis
expand all
Example tests
1.
0.040 s
WRONG ANSWER,
got [] expected [2, 3]
stdout:
Start_index = 0 Array: [2, 1, 3, 1, 2, 2, 3], leader: None Start_index = 1 Array: [2, 1, 3, 1, 2, 2, 3], leader: None Start_index = 2 Array: [2, 1, 3, 1, 2, 2, 3], leader: None Start_index = 3 Array: [2, 1, 3, 1, 2, 2, 3], leader: None Start_index = 4 Array: [2, 1, 3, 1, 2, 2, 3], leader: None
1.
0.040 s
WRONG ANSWER,
got [2] expected [2, 3]
stdout:
Start_index = 0 Array: [1, 2, 2, 1, 2], leader: 2 Start_index = 1 Array: [1, 2, 2, 1, 2], leader: 2
Code: 17:21:09 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
print("Array: {}, leader: {}".format(A, leader))
return leader
def increment_segment(A, K, start_index):
##print("Start_index = {}".format(start_index))
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Code: 17:21:12 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
print("Array: {}, leader: {}".format(A, leader))
return leader
def increment_segment(A, K, start_index):
##print("Start_index = {}".format(start_index))
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Analysis
expand all
Example tests
1.
0.040 s
WRONG ANSWER,
got [] expected [2, 3]
stdout:
Array: [2, 1, 3, 1, 2, 2, 3], leader: None Array: [2, 1, 3, 1, 2, 2, 3], leader: None Array: [2, 1, 3, 1, 2, 2, 3], leader: None Array: [2, 1, 3, 1, 2, 2, 3], leader: None Array: [2, 1, 3, 1, 2, 2, 3], leader: None
1.
0.040 s
WRONG ANSWER,
got [2] expected [2, 3]
stdout:
Array: [1, 2, 2, 1, 2], leader: 2 Array: [1, 2, 2, 1, 2], leader: 2
Code: 17:21:40 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
print("Array: {}, leader: {}".format(A, leader))
return leader
def increment_segment(A, K, start_index):
##print("Start_index = {}".format(start_index))
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A_c)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Code: 17:21:45 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
print("Array: {}, leader: {}".format(A, leader))
return leader
def increment_segment(A, K, start_index):
##print("Start_index = {}".format(start_index))
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A_c)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Analysis
expand all
Example tests
1.
0.036 s
OK
stdout:
Array: [3, 2, 4, 1, 2, 2, 3], leader: None Array: [2, 2, 4, 2, 2, 2, 3], leader: 2 Array: [2, 1, 4, 2, 3, 2, 3], leader: None Array: [2, 1, 3, 2, 3, 3, 3], leader: 3 Array: [2, 1, 3, 1, 3, 3, 4], leader: None
1.
0.036 s
OK
stdout:
Array: [2, 3, 3, 2, 2], leader: 2 Array: [1, 3, 3, 2, 3], leader: 3
Code: 17:22:00 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A_c)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Analysis
Code: 17:22:24 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A_c)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Code: 17:22:34 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def move_segment(
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A_c)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Code: 17:22:49 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def move_increment(A, K,
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A_c)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Code: 17:22:59 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def move_increment(A, K, start_index):
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A_c)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Code: 17:23:29 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def move_increment(A, K, start_index):
A[i]
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A_c)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Code: 17:23:43 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def move_increment(A, K, start_index):
A[i] -= 1
A[i+K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A_c)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Code: 17:23:58 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def move_increment(A, K, start_index):
A[i] -= 1
A[i+K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A_c)
if leader:
leaders.add(leader)
leaders_list = list(leaders)
return sorted(list(leaders))
Code: 17:24:09 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def move_increment(A, K, start_index):
A[i] -= 1
A[i+K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A_c)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:24:43 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def move_increment(A, K, start_index):
A[i] -= 1
A[i+K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A_c)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:25:13 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_fist_segment(A, K):
for i in
def move_increment(A, K, start_index):
A[i] -= 1
A[i+K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A_c)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:25:33 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_fist_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, start_index):
A[i] -= 1
A[i+K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A_c)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:25:44 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_fist_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, start_index):
A[i] -= 1
A[i+K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A_c)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:26:01 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_fist_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, start_index):
A[i] -= 1
A[i+K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
if
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A_c)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:26:13 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_fist_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, start_index):
A[i] -= 1
A[i+K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A_c)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:26:26 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_fist_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, start_index):
A[i] -= 1
A[i+K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = i_k
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A_c)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:27:36 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_fist_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, start_index):
A[i] -= 1
A[i+K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = i_
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A_c)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:27:59 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_fist_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, start_index):
A[i] -= 1
A[i+K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A_c)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:27:59 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_fist_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, start_index):
A[i] -= 1
A[i+K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A_c)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Analysis
expand all
Example tests
1.
0.040 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 149, in <module>
main()
File "exec.py", line 111, in main
result = solution( K, M, A )
File "/tmp/solution.py", line 33, in solution
increment_first_segment(A, K)
NameError: name 'increment_first_segment' is not defined
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 149, in <module>
main()
File "exec.py", line 111, in main
result = solution( K, M, A )
File "/tmp/solution.py", line 33, in solution
increment_first_segment(A, K)
NameError: name 'increment_first_segment' is not defined
Code: 17:28:16 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, start_index):
A[i] -= 1
A[i+K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N-K+1):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A_c)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Analysis
expand all
Example tests
1.
0.040 s
WRONG ANSWER,
got [3] expected [2, 3]
1.
0.040 s
WRONG ANSWER,
got [2] expected [2, 3]
Code: 17:28:48 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, start_index):
A[i] -= 1
A[i+K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N-K):
A_c = copy(A)
increment_segment(A_c, K, i)
leader = get_leader(A_c)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:29:18 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, start_index):
A[i] -= 1
A[i+K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N-K):
move_segment
increment_segment(A_c, K, i)
leader = get_leader(A_c)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:29:28 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, start_index):
A[i] -= 1
A[i+K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N-K):
move_segment(A, K, i)
increment_segment(A_c, K, i)
leader = get_leader(A_c)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:29:49 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, start_index):
A[i] -= 1
A[i+K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N-K):
move_segment(A, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
increment_segment(A_c, K, i)
leader = get_leader(A_c)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:30:01 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, start_index):
A[i] -= 1
A[i+K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N-K):
move_segment(A, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:30:01 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, start_index):
A[i] -= 1
A[i+K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N-K):
move_segment(A, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Analysis
expand all
Example tests
1.
0.040 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 149, in <module>
main()
File "exec.py", line 111, in main
result = solution( K, M, A )
File "/tmp/solution.py", line 39, in solution
move_segment(A, K, i)
NameError: name 'move_segment' is not defined
1.
0.040 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 149, in <module>
main()
File "exec.py", line 111, in main
result = solution( K, M, A )
File "/tmp/solution.py", line 39, in solution
move_segment(A, K, i)
NameError: name 'move_segment' is not defined
Code: 17:30:09 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, start_index):
A[i] -= 1
A[i+K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N-K):
move_increment(A, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Analysis
expand all
Example tests
1.
0.040 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 149, in <module>
main()
File "exec.py", line 111, in main
result = solution( K, M, A )
File "/tmp/solution.py", line 39, in solution
move_increment(A, K, i)
File "/tmp/solution.py", line 25, in move_increment
A[i] -= 1
NameError: name 'i' is not defined
1.
0.040 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 149, in <module>
main()
File "exec.py", line 111, in main
result = solution( K, M, A )
File "/tmp/solution.py", line 39, in solution
move_increment(A, K, i)
File "/tmp/solution.py", line 25, in move_increment
A[i] -= 1
NameError: name 'i' is not defined
Code: 17:30:30 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, start_index):
A[start_index] -= 1
A[i+K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N-K):
move_increment(A, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:30:40 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
from copy import copy
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N-K):
move_increment(A, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Analysis
Code: 17:31:10 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N-K):
move_increment(A, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:31:11 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N-K):
move_increment(A, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Analysis
Code: 17:31:31 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N-K):
move_increment(A, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:32:09 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N-K):
move_increment(A, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:32:23 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def get_leader_counter(counter):
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N-K):
move_increment(A, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:33:32 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def get_leader_counter(counter):
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N-K):
move_increment(A, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:34:37 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def get_leader_counter(counter):
N
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N-K):
move_increment(A, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:34:49 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def get_leader_counter(counter):
N = sum(counter.values())
element, count =
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N-K):
move_increment(A, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:35:06 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def get_leader_counter(counter):
N = sum(counter.values())
element, count = counter.most_common(1)[0]
leader = None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N-K):
move_increment(A, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:35:27 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def get_leader_counter(counter):
N = sum(counter.values())
element, count = counter.most_common(1)[0]
if count > N/2:
return element
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N-K):
move_increment(A, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:35:40 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
leader = element
return leader
def get_leader_counter(counter):
N = sum(counter.values())
element, count = counter.most_common(1)[0]
if count > N/2:
return element
return None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N-K):
move_increment(A, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:35:52 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
leader = None
N = len(A)
if count > N/2:
return element
return leader
def get_leader_counter(counter):
N = sum(counter.values())
element, count = counter.most_common(1)[0]
if count > N/2:
return element
return None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N-K):
move_increment(A, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:36:03 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
N = len(A)
if count > N/2:
return element
return None
def get_leader_counter(counter):
N = sum(counter.values())
element, count = counter.most_common(1)[0]
if count > N/2:
return element
return None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N-K):
move_increment(A, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:36:41 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
N = len(A)
if count > N/2:
return element
return None
def get_leader_counter(counter):
N = sum(counter.values())
element, count = counter.most_common(1)[0]
if count > N/2:
return element
return None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N-K):
move_increment(A, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:36:55 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
N = len(A)
if count > N/2:
return element
return None
def get_leader_counter(counter):
N = sum(counter.values())
element, count = counter.most_common(1)[0]
if count > N/2:
return element
return None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
counter = Counter(A)
first_leader = get_leader_counter(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N-K):
move_increment(A, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:38:26 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
N = len(A)
if count > N/2:
return element
return None
def get_leader_counter(counter):
N = sum(counter.values())
element, count = counter.most_common(1)[0]
if count > N/2:
return element
return None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
counter = Counter(A)
first_leader = get_leader_counter(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N-K):
move_increment(A, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:38:45 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
N = len(A)
if count > N/2:
return element
return None
def get_leader_counter(counter):
N = sum(counter.values())
element, count = counter.most_common(1)[0]
if count > N/2:
return element
return None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
counter = Counter(A)
first_leader = get_leader_counter(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N-K):
indices = [i, i + K]
move_increment(A, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:39:07 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
N = len(A)
if count > N/2:
return element
return None
def get_leader_counter(counter):
N = sum(counter.values())
element, count = counter.most_common(1)[0]
if count > N/2:
return element
return None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
counter = Counter(A)
first_leader = get_leader_counter(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N - K):
indices = [i, i + K]
move_increment(A, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:39:37 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
N = len(A)
if count > N/2:
return element
return None
def get_leader_counter(counter):
N = sum(counter.values())
element, count = counter.most_common(1)[0]
if count > N/2:
return element
return None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
counter = Counter(A)
first_leader = get_leader_counter(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N - K):
indices = [i, i + K]
move_increment(A, K, i)
leader = get_leader_counter(counter()
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:39:48 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
N = len(A)
if count > N/2:
return element
return None
def get_leader_counter(counter):
N = sum(counter.values())
element, count = counter.most_common(1)[0]
if count > N/2:
return element
return None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
counter = Counter(A)
first_leader = get_leader_counter(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N - K):
indices = [i, i + K]
move_increment(A, K, i)
leader = get_leader_counter(counter)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:39:59 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
N = len(A)
if count > N/2:
return element
return None
def get_leader_counter(counter):
N = sum(counter.values())
element, count = counter.most_common(1)[0]
if count > N/2:
return element
return None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
counter = Counter(A)
first_leader = get_leader_counter(counter)
if first_leader:
leaders.add(first_leader)
for i in range(0, N - K):
indices = [i, i + K]
move_increment(A, K, i)
leader = get_leader_counter(counter)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:40:09 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
N = len(A)
if count > N/2:
return element
return None
def get_leader_counter(counter):
N = sum(counter.values())
element, count = counter.most_common(1)[0]
if count > N/2:
return element
return None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
counter = Counter(A)
first_leader = get_leader_counter(counter)
if first_leader:
leaders.add(first_leader)
for i in range(0, N - K):
indices = [i, i + K]
leader = get_leader_counter(counter)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:40:51 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
N = len(A)
if count > N/2:
return element
return None
def get_leader_counter(counter):
N = sum(counter.values())
element, count = counter.most_common(1)[0]
if count > N/2:
return element
return None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
counter = Counter(A)
first_leader = get_leader_counter(counter)
if first_leader:
leaders.add(first_leader)
for i in range(0, N - K):
indices = [i, i + K]
leader = get_leader_counter(counter)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:41:04 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
N = len(A)
if count > N/2:
return element
return None
def get_leader_counter(counter):
N = sum(counter.values())
element, count = counter.most_common(1)[0]
if count > N/2:
return element
return None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def move_increment_counter(A,
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
counter = Counter(A)
first_leader = get_leader_counter(counter)
if first_leader:
leaders.add(first_leader)
for i in range(0, N - K):
indices = [i, i + K]
leader = get_leader_counter(counter)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:41:14 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
N = len(A)
if count > N/2:
return element
return None
def get_leader_counter(counter):
N = sum(counter.values())
element, count = counter.most_common(1)[0]
if count > N/2:
return element
return None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def move_increment_counter(A, counter, index):
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
counter = Counter(A)
first_leader = get_leader_counter(counter)
if first_leader:
leaders.add(first_leader)
for i in range(0, N - K):
indices = [i, i + K]
leader = get_leader_counter(counter)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:42:54 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
N = len(A)
if count > N/2:
return element
return None
def get_leader_counter(counter):
N = sum(counter.values())
element, count = counter.most_common(1)[0]
if count > N/2:
return element
return None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def move_increment_counter(A, counter, index):
counte
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
counter = Counter(A)
first_leader = get_leader_counter(counter)
if first_leader:
leaders.add(first_leader)
for i in range(0, N - K):
indices = [i, i + K]
leader = get_leader_counter(counter)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:43:06 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
N = len(A)
if count > N/2:
return element
return None
def get_leader_counter(counter):
N = sum(counter.values())
element, count = counter.most_common(1)[0]
if count > N/2:
return element
return None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def move_increment_counter(A, counter, index):
counter(A[index]
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
counter = Counter(A)
first_leader = get_leader_counter(counter)
if first_leader:
leaders.add(first_leader)
for i in range(0, N - K):
indices = [i, i + K]
leader = get_leader_counter(counter)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:43:36 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
N = len(A)
if count > N/2:
return element
return None
def get_leader_counter(counter):
N = sum(counter.values())
element, count = counter.most_common(1)[0]
if count > N/2:
return element
return None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def move_increment_counter(A, counter, index, K):
counter(A[index]) -= 1
coun
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
counter = Counter(A)
first_leader = get_leader_counter(counter)
if first_leader:
leaders.add(first_leader)
for i in range(0, N - K):
indices = [i, i + K]
leader = get_leader_counter(counter)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:43:47 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
N = len(A)
if count > N/2:
return element
return None
def get_leader_counter(counter):
N = sum(counter.values())
element, count = counter.most_common(1)[0]
if count > N/2:
return element
return None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def move_increment_counter(A, counter, index, K):
counter(A[index]) -= 1
counter(A[
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
counter = Counter(A)
first_leader = get_leader_counter(counter)
if first_leader:
leaders.add(first_leader)
for i in range(0, N - K):
indices = [i, i + K]
leader = get_leader_counter(counter)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:46:47 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
N = len(A)
if count > N/2:
return element
return None
def get_leader_counter(counter):
N = sum(counter.values())
element, count = counter.most_common(1)[0]
if count > N/2:
return element
return None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
counter = Counter(A)
first_leader = get_leader_counter(counter)
if first_leader:
leaders.add(first_leader)
for i in range(0, N - K):
indices = [i, i + K]
leader = get_leader_counter(counter)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:47:18 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
N = len(A)
if count > N/2:
return element
return None
def get_leader_counter(counter):
N = sum(counter.values())
element, count = counter.most_common(1)[0]
if count > N/2:
return element
return None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader_counter(counter)
if first_leader:
leaders.add(first_leader)
for i in range(0, N - K):
indices = [i, i + K]
leader = get_leader_counter(counter)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:47:29 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
N = len(A)
if count > N/2:
return element
return None
def get_leader_counter(counter):
N = sum(counter.values())
element, count = counter.most_common(1)[0]
if count > N/2:
return element
return None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N - K):
indices = [i, i + K]
leader = get_leader_counter(counter)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:47:47 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
N = len(A)
if count > N/2:
return element
return None
def get_leader_counter(counter):
N = sum(counter.values())
element, count = counter.most_common(1)[0]
if count > N/2:
return element
return None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N - K):
move_increment(A, K, index)
leader = get_leader_counter(counter)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:47:59 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
N = len(A)
if count > N/2:
return element
return None
def get_leader_counter(counter):
N = sum(counter.values())
element, count = counter.most_common(1)[0]
if count > N/2:
return element
return None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N - K):
move_increment(A, K, i)
leader = get_leader(counter)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:48:09 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
N = len(A)
if count > N/2:
return element
return None
def get_leader_counter(counter):
N = sum(counter.values())
element, count = counter.most_common(1)[0]
if count > N/2:
return element
return None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N - K):
move_increment(A, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:48:24 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
N = len(A)
if count > N/2:
return element
return None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N - K):
move_increment(A, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Code: 17:48:28 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
N = len(A)
if count > N/2:
return element
return None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N - K):
move_increment(A, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Analysis
Code: 17:48:40 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
N = len(A)
if count > N/2:
return element
return None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N - K):
move_increment(A, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Analysis
Code: 17:48:42 UTC,
py,
final,
score:
55
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from collections import Counter
def get_leader(A):
counter = Counter(A)
element, count = counter.most_common(1)[0]
N = len(A)
if count > N/2:
return element
return None
def increment_segment(A, K, start_index):
B = A[start_index:start_index + K]
B = [x+1 for x in B]
A[start_index:start_index+K] = B
def increment_first_segment(A, K):
for i in range(0, K):
A[i] += 1
def move_increment(A, K, index):
A[index] -= 1
A[index + K] +=1
def solution(K, M, A):
leaders = set()
N = len(A)
increment_first_segment(A, K)
first_leader = get_leader(A)
if first_leader:
leaders.add(first_leader)
for i in range(0, N - K):
move_increment(A, K, i)
leader = get_leader(A)
if leader:
leaders.add(leader)
return sorted(list(leaders))
Analysis summary
The following issues have been detected: timeout errors.
Analysis
Detected time complexity:
O(N*(N+M)) or O(N**2)
expand all
Correctness tests
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
4.
0.036 s
OK
5.
0.036 s
OK
6.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
4.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
expand all
Performance tests
medium_tests1
medium tests (N = 10000, M = 100)
medium tests (N = 10000, M = 100)
✘
TIMEOUT ERROR
running time: 3.988 sec., time limit: 0.208 sec.
running time: 3.988 sec., time limit: 0.208 sec.
1.
3.988 s
TIMEOUT ERROR,
running time: 3.988 sec., time limit: 0.208 sec.
2.
5.312 s
TIMEOUT ERROR,
running time: 5.312 sec., time limit: 0.224 sec.
3.
5.444 s
TIMEOUT ERROR,
running time: 5.444 sec., time limit: 0.224 sec.
medium_tests2
medium tests(N >= 20000, M=30000)
medium tests(N >= 20000, M=30000)
✘
TIMEOUT ERROR
Killed. Hard limit reached: 6.000 sec.
Killed. Hard limit reached: 6.000 sec.
1.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
2.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
3.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
1.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
2.
7.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 7.000 sec.
3.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
1.
0.152 s
OK
2.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.