Tasks Details
medium
Find the side length of the biggest black square in a matrix. In each column, black cells start at the bottom of the matrix and count up.
Task Score
100%
Correctness
100%
Performance
100%
You are given an N × N matrix in which every cell is colored black or white. Columns are numbered from 0 to N-1 (from left to right). This coloring is represented by a non-empty array of integers A. If the K-th number in the array is equal to X then the X lowest cells in the K-th column of the matrix are black. The rest of the cells in the K-th column are white. The task is to calculate the side length of the biggest black square (a square containing only black cells).
Write a function:
def solution(A)
that, given an array of integers A of length N representing the coloring of the matrix, returns the side length of the biggest black square.
Examples:
1. Given A = [1, 2, 5, 3, 1, 3], the function should return 2. For example, the black square of side 2 contains the two lowest rows of the 1st and 2nd columns (counting from 0).
![The picture describes the first example test [1, 2, 5, 3, 1, 3].](https://codility-frontend-prod.s3.amazonaws.com/media/task_static/max_square_on_matrix/static/images/auto/a239141bf78ea877bfd84d5b6c5d27eb.png)
2. Given A = [3, 3, 3, 5, 4], the function should return 3. For example, the biggest black square has side 3 and contains the three lowest rows of the last three columns.
![The picture describes the second example test [3, 3, 3, 5, 4].](https://codility-frontend-prod.s3.amazonaws.com/media/task_static/max_square_on_matrix/static/images/auto/f93c01c901739dfbca08e866359484f2.png)
3. Given A = [6, 5, 5, 6, 2, 2], the function should return 4. The biggest black square has side 4 and contains the four lowest rows of the first four columns.
![The picture describes the third example test [6, 5, 5, 6, 2, 2].](https://codility-frontend-prod.s3.amazonaws.com/media/task_static/max_square_on_matrix/static/images/auto/149f2bd0051e4c8106205b1ab023e4d5.png)
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..100,000];
- each element of array A is an integer within the range [1..N].
Copyright 2009–2025 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Solution
Programming language used Python
Time spent on task 26 minutes
Notes
not defined yet
Code: 15:39:31 UTC,
java,
autosave
Analysis
expand all
Example tests
1.
0.040 s
WRONG ANSWER,
got 1 expected 2
1.
0.036 s
WRONG ANSWER,
got 1 expected 3
1.
0.036 s
WRONG ANSWER,
got 1 expected 4
Analysis
expand all
Example tests
1.
0.036 s
WRONG ANSWER,
got 1 expected 2
1.
0.040 s
WRONG ANSWER,
got 1 expected 3
1.
0.036 s
WRONG ANSWER,
got 1 expected 4
expand all
User tests
1.
0.001 s
RUNTIME ERROR,
invalid input, unexpected character: *
User test case 1:
[10]*10
Code: 15:43:48 UTC,
py,
verify,
result: Failed
Analysis
expand all
Example tests
1.
0.036 s
WRONG ANSWER,
got 1 expected 2
stdout:
{1: [0, 4], 2: [1], 5: [2], 3: [3, 5]}
1.
0.036 s
WRONG ANSWER,
got 1 expected 3
stdout:
{3: [0, 1, 2], 5: [3], 4: [4]}
1.
0.040 s
WRONG ANSWER,
got 1 expected 4
stdout:
{6: [0, 3], 5: [1, 2], 2: [4, 5]}
expand all
User tests
1.
0.001 s
RUNTIME ERROR,
invalid input, unexpected character: *
User test case 1:
[10]*10
Code: 15:43:58 UTC,
py,
autosave
Code: 15:43:58 UTC,
py,
verify,
result: Failed
Analysis
expand all
Example tests
1.
0.036 s
WRONG ANSWER,
got 1 expected 2
stdout:
{1: [0, 4], 2: [1], 5: [2], 3: [3, 5]}
1.
0.036 s
WRONG ANSWER,
got 1 expected 3
stdout:
{3: [0, 1, 2], 5: [3], 4: [4]}
1.
0.036 s
WRONG ANSWER,
got 1 expected 4
stdout:
{6: [0, 3], 5: [1, 2], 2: [4, 5]}
User test case 1:
[10]
Code: 15:44:39 UTC,
py,
autosave
Code: 15:44:58 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
print(heights)
print(height_locs)
return 1
Code: 15:45:11 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
return 1
Analysis
expand all
Example tests
1.
0.036 s
WRONG ANSWER,
got 1 expected 2
stdout:
[5, 3, 2, 1]
{1: [0, 4], 2: [1], 5: [2], 3: [3, 5]}
1.
0.036 s
WRONG ANSWER,
got 1 expected 3
stdout:
[5, 4, 3]
{3: [0, 1, 2], 5: [3], 4: [4]}
1.
0.036 s
WRONG ANSWER,
got 1 expected 4
stdout:
[6, 5, 2]
{6: [0, 3], 5: [1, 2], 2: [4, 5]}
User test case 1:
[10]
Code: 15:45:28 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
for h
return 1
Code: 15:45:39 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
for h in heights:
return 1
Code: 15:45:49 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
for h in heights:
for idx in
return 1
Code: 15:46:19 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
for h in heights:
for idx in height_locs[h]:
return 1
Code: 15:46:30 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
for h in heights:
for idx in height_locs[h]:
return 1
Code: 15:46:51 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
for h in heights:
for idx in height_locs[h]:
return 1
Code: 15:47:04 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
for h in heights:
for idx in height_locs[h]:
squares[idx] = 1
return 1
Code: 15:47:17 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
for h in heights:
for idx in height_locs[h]:
squares[idx] = 1
if idx > 0:
return 1
Code: 15:47:30 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
for h in heights:
for idx in height_locs[h]:
squares[idx] = 1
if idx > 0:
left
return 1
Code: 15:47:49 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
for h in heights:
for idx in height_locs[h]:
squares[idx] = 1
if idx > 0:
left = squares[idx-1]
else:
left = 0
return 1
Code: 15:47:59 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
for h in heights:
for idx in height_locs[h]:
squares[idx] = 1
if idx > 0:
left = squares[idx-1]
left = 0
return 1
Code: 15:48:13 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
for h in heights:
for idx in height_locs[h]:
squares[idx] = 1
left = 0
if idx > 0: left = squares[idx-1]
return 1
Code: 15:48:32 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
for h in heights:
for idx in height_locs[h]:
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
return 1
Code: 15:48:42 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
for h in heights:
for idx in height_locs[h]:
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
squares[idx]
return 1
Code: 15:48:53 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
for h in heights:
for idx in height_locs[h]:
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
squares[idx - left]
return 1
Code: 15:49:17 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
for h in heights:
for idx in height_locs[h]:
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
squares[idx - left] += 1
return 1
Code: 15:49:48 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
for h in heights:
for idx in height_locs[h]:
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
return 1
Code: 15:50:06 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
for h in heights:
for idx in height_locs[h]:
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] += squares[idx-left]
return 1
Code: 15:50:24 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
for h in heights:
for idx in height_locs[h]:
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] += squares[idx-left]
right = squares[idx+1] if idx
return 1
Code: 15:50:54 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
for h in heights:
for idx in height_locs[h]:
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] += squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx]
return 1
Code: 15:51:11 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
for h in heights:
for idx in height_locs[h]:
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] += squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
return 1
Code: 15:51:29 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
for h in heights:
for idx in height_locs[h]:
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] += squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] += squares
return 1
Code: 15:51:50 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
for h in heights:
for idx in height_locs[h]:
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] += squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
return 1
Code: 15:52:13 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
for h in heights:
for idx in height_locs[h]:
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] += squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >=
return 1
Code: 15:52:31 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
for h in heights:
for idx in height_locs[h]:
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] += squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= h:
return squares[idx-left]
return 1
Code: 15:52:52 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
for h in heights:
for idx in height_locs[h]:
if
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] += squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= h:
return h
return 1
Code: 15:53:14 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
biggestSquare = 0
for h in heights:
for idx in height_locs[h]:
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] += squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= h:
return h
return 1
Code: 15:53:34 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
biggestSquare = 0
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] += squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= h:
return h
return 1
Code: 15:53:59 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
biggestSquare = 0
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] += squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
return h
return 1
Code: 15:54:10 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
biggestSquare = 0
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] += squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
if biggestSquare
return h
return 1
Code: 15:54:20 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
biggestSquare = 0
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] += squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
if biggestSquare >= h
return h
return 1
Code: 15:54:30 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
biggestSquare = 0
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] += squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
if biggestSquare >= h:
return h
return 1
Analysis
expand all
Example tests
1.
0.036 s
OK
stdout:
[5, 3, 2, 1]
{1: [0, 4], 2: [1], 5: [2], 3: [3, 5]}
1.
0.036 s
OK
stdout:
[5, 4, 3]
{3: [0, 1, 2], 5: [3], 4: [4]}
1.
0.036 s
WRONG ANSWER,
got 3 expected 4
stdout:
[6, 5, 2]
{6: [0, 3], 5: [1, 2], 2: [4, 5]}
User test case 1:
[10]
Code: 15:54:50 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
biggestSquare = 0
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] += squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
print()
if biggestSquare >= h:
return h
return 1
Code: 15:54:52 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
biggestSquare = 0
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] += squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
print(squares)
if biggestSquare >= h:
return h
return 1
Analysis
expand all
Example tests
1.
0.040 s
OK
stdout:
[5, 3, 2, 1]
{1: [0, 4], 2: [1], 5: [2], 3: [3, 5]}
[0, 0, 1, 0, 0, 0]
[0, 0, 2, 3, 0, 0]
[0, 0, 2, 3, 0, 1]
[0, 4, 2, 4, 0, 1]
1.
0.036 s
OK
stdout:
[5, 4, 3]
{3: [0, 1, 2], 5: [3], 4: [4]}
[0, 0, 0, 1, 0]
[0, 0, 0, 2, 3]
[1, 0, 0, 2, 3]
[2, 3, 0, 2, 3]
[2, 3, 5, 2, 9]
1.
0.036 s
WRONG ANSWER,
got 3 expected 4
stdout:
[6, 5, 2]
{6: [0, 3], 5: [1, 2], 2: [4, 5]}
[1, 0, 0, 0, 0, 0]
[1, 0, 0, 1, 0, 0]
[2, 3, 0, 1, 0, 0]
[2, 3, 2, 3, 0, 3]
User test case 1:
[10]
Code: 15:55:34 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
biggestSquare = 0
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] = squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
print(squares)
if biggestSquare >= h:
return h
return 1
Code: 15:55:35 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
biggestSquare = 0
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] = squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
print(squares)
if biggestSquare >= h:
return h
return 1
Analysis
expand all
Example tests
1.
0.036 s
OK
stdout:
[5, 3, 2, 1]
{1: [0, 4], 2: [1], 5: [2], 3: [3, 5]}
[0, 0, 1, 0, 0, 0]
[0, 0, 2, 2, 0, 0]
[0, 0, 2, 2, 0, 1]
[0, 3, 2, 3, 0, 1]
1.
0.036 s
OK
stdout:
[5, 4, 3]
{3: [0, 1, 2], 5: [3], 4: [4]}
[0, 0, 0, 1, 0]
[0, 0, 0, 2, 2]
[1, 0, 0, 2, 2]
[2, 2, 0, 2, 2]
[5, 2, 3, 2, 5]
1.
0.040 s
OK
stdout:
[6, 5, 2]
{6: [0, 3], 5: [1, 2], 2: [4, 5]}
[1, 0, 0, 0, 0, 0]
[1, 0, 0, 1, 0, 0]
[2, 2, 0, 1, 0, 0]
[4, 2, 3, 4, 0, 0]
User test case 1:
[10]
Code: 15:56:17 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
biggestSquare = 0
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] = squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
print(squares)
if biggestSquare >= h:
return h
return 1
Code: 15:56:28 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
biggestSquare = 0
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] = squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
print(squares)
if biggestSquare >= h:
return h
return 1
Code: 15:56:33 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
biggestSquare = 0
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] = squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
print(squares)
if biggestSquare >= h:
return h
return 1
Analysis
expand all
Example tests
1.
0.036 s
OK
stdout:
[5, 3, 2, 1]
{1: [0, 4], 2: [1], 5: [2], 3: [3, 5]}
[0, 0, 1, 0, 0, 0]
[0, 0, 2, 2, 0, 0]
[0, 0, 2, 2, 0, 1]
[0, 3, 2, 3, 0, 1]
1.
0.036 s
OK
stdout:
[5, 4, 3]
{3: [0, 1, 2], 5: [3], 4: [4]}
[0, 0, 0, 1, 0]
[0, 0, 0, 2, 2]
[1, 0, 0, 2, 2]
[2, 2, 0, 2, 2]
[5, 2, 3, 2, 5]
1.
0.036 s
OK
stdout:
[6, 5, 2]
{6: [0, 3], 5: [1, 2], 2: [4, 5]}
[1, 0, 0, 0, 0, 0]
[1, 0, 0, 1, 0, 0]
[2, 2, 0, 1, 0, 0]
[4, 2, 3, 4, 0, 0]
expand all
User tests
1.
0.036 s
OK
function result: 10
function result: 10
stdout:
[10]
{10: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0, 0]
[5, 2, 3, 4, 5, 0, 0, 0, 0, 0]
[6, 2, 3, 4, 5, 6, 0, 0, 0, 0]
[7, 2, 3, 4, 5, 6, 7, 0, 0, 0]
[8, 2, 3, 4, 5, 6, 7, 8, 0, 0]
[9, 2, 3, 4, 5, 6, 7, 8, 9, 0]
[10, 2, 3, 4, 5, 6, 7, 8, 9, 10]
1.
0.036 s
OK
function result: 1
function result: 1
stdout:
[10]
{10: [0, 1, 2, 3, 4, 5, 6, 7, 8]}
[1, 0, 0, 0, 0, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0]
[5, 2, 3, 4, 5, 0, 0, 0, 0]
[6, 2, 3, 4, 5, 6, 0, 0, 0]
[7, 2, 3, 4, 5, 6, 7, 0, 0]
[8, 2, 3, 4, 5, 6, 7, 8, 0]
[9, 2, 3, 4, 5, 6, 7, 8, 9]
1.
0.036 s
OK
function result: 10
function result: 10
stdout:
[10]
{10: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]}
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0]
[5, 2, 3, 4, 5, 0, 0, 0, 0, 0, 0]
[6, 2, 3, 4, 5, 6, 0, 0, 0, 0, 0]
[7, 2, 3, 4, 5, 6, 7, 0, 0, 0, 0]
[8, 2, 3, 4, 5, 6, 7, 8, 0, 0, 0]
[9, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0]
[10, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0]
User test case 1:
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 2:
[10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 3:
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
Code: 15:57:32 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
biggestSquare = 0
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] = squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
print(squares)
if biggestSquare >= h:
return h
return return
Code: 15:57:40 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
biggestSquare = 0
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] = squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
print(squares)
if biggestSquare >= h:
return h
return max(squares)
Analysis
expand all
Example tests
1.
0.036 s
OK
stdout:
[5, 3, 2, 1]
{1: [0, 4], 2: [1], 5: [2], 3: [3, 5]}
[0, 0, 1, 0, 0, 0]
[0, 0, 2, 2, 0, 0]
[0, 0, 2, 2, 0, 1]
[0, 3, 2, 3, 0, 1]
1.
0.036 s
OK
stdout:
[5, 4, 3]
{3: [0, 1, 2], 5: [3], 4: [4]}
[0, 0, 0, 1, 0]
[0, 0, 0, 2, 2]
[1, 0, 0, 2, 2]
[2, 2, 0, 2, 2]
[5, 2, 3, 2, 5]
1.
0.036 s
OK
stdout:
[6, 5, 2]
{6: [0, 3], 5: [1, 2], 2: [4, 5]}
[1, 0, 0, 0, 0, 0]
[1, 0, 0, 1, 0, 0]
[2, 2, 0, 1, 0, 0]
[4, 2, 3, 4, 0, 0]
expand all
User tests
1.
0.036 s
OK
function result: 10
function result: 10
stdout:
[10]
{10: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0, 0]
[5, 2, 3, 4, 5, 0, 0, 0, 0, 0]
[6, 2, 3, 4, 5, 6, 0, 0, 0, 0]
[7, 2, 3, 4, 5, 6, 7, 0, 0, 0]
[8, 2, 3, 4, 5, 6, 7, 8, 0, 0]
[9, 2, 3, 4, 5, 6, 7, 8, 9, 0]
[10, 2, 3, 4, 5, 6, 7, 8, 9, 10]
1.
0.036 s
OK
function result: 9
function result: 9
stdout:
[10]
{10: [0, 1, 2, 3, 4, 5, 6, 7, 8]}
[1, 0, 0, 0, 0, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0]
[5, 2, 3, 4, 5, 0, 0, 0, 0]
[6, 2, 3, 4, 5, 6, 0, 0, 0]
[7, 2, 3, 4, 5, 6, 7, 0, 0]
[8, 2, 3, 4, 5, 6, 7, 8, 0]
[9, 2, 3, 4, 5, 6, 7, 8, 9]
1.
0.036 s
OK
function result: 10
function result: 10
stdout:
[10]
{10: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]}
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0]
[5, 2, 3, 4, 5, 0, 0, 0, 0, 0, 0]
[6, 2, 3, 4, 5, 6, 0, 0, 0, 0, 0]
[7, 2, 3, 4, 5, 6, 7, 0, 0, 0, 0]
[8, 2, 3, 4, 5, 6, 7, 8, 0, 0, 0]
[9, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0]
[10, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0]
User test case 1:
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 2:
[10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 3:
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
Code: 16:00:10 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
biggestSquare = 0
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] = squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
print(squares)
if biggestSquare >= h:
return h
return max(squares)
Code: 16:00:18 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
biggestSquare = 0
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] = squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
print(squares)
if biggestSquare >= h:
return h
return max(squares)
Analysis
expand all
Example tests
1.
0.036 s
OK
stdout:
[5, 3, 2, 1]
{1: [0, 4], 2: [1], 5: [2], 3: [3, 5]}
[0, 0, 1, 0, 0, 0]
[0, 0, 2, 2, 0, 0]
[0, 0, 2, 2, 0, 1]
[0, 3, 2, 3, 0, 1]
1.
0.036 s
OK
stdout:
[5, 4, 3]
{3: [0, 1, 2], 5: [3], 4: [4]}
[0, 0, 0, 1, 0]
[0, 0, 0, 2, 2]
[1, 0, 0, 2, 2]
[2, 2, 0, 2, 2]
[5, 2, 3, 2, 5]
1.
0.036 s
OK
stdout:
[6, 5, 2]
{6: [0, 3], 5: [1, 2], 2: [4, 5]}
[1, 0, 0, 0, 0, 0]
[1, 0, 0, 1, 0, 0]
[2, 2, 0, 1, 0, 0]
[4, 2, 3, 4, 0, 0]
expand all
User tests
1.
0.036 s
OK
function result: 10
function result: 10
stdout:
[10]
{10: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0, 0]
[5, 2, 3, 4, 5, 0, 0, 0, 0, 0]
[6, 2, 3, 4, 5, 6, 0, 0, 0, 0]
[7, 2, 3, 4, 5, 6, 7, 0, 0, 0]
[8, 2, 3, 4, 5, 6, 7, 8, 0, 0]
[9, 2, 3, 4, 5, 6, 7, 8, 9, 0]
[10, 2, 3, 4, 5, 6, 7, 8, 9, 10]
1.
0.036 s
OK
function result: 9
function result: 9
stdout:
[10]
{10: [0, 1, 2, 3, 4, 5, 6, 7, 8]}
[1, 0, 0, 0, 0, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0]
[5, 2, 3, 4, 5, 0, 0, 0, 0]
[6, 2, 3, 4, 5, 6, 0, 0, 0]
[7, 2, 3, 4, 5, 6, 7, 0, 0]
[8, 2, 3, 4, 5, 6, 7, 8, 0]
[9, 2, 3, 4, 5, 6, 7, 8, 9]
1.
0.036 s
OK
function result: 10
function result: 10
stdout:
[10]
{10: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]}
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0]
[5, 2, 3, 4, 5, 0, 0, 0, 0, 0, 0]
[6, 2, 3, 4, 5, 6, 0, 0, 0, 0, 0]
[7, 2, 3, 4, 5, 6, 7, 0, 0, 0, 0]
[8, 2, 3, 4, 5, 6, 7, 8, 0, 0, 0]
[9, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0]
[10, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0]
1.
0.036 s
OK
function result: 4
function result: 4
stdout:
[5, 4]
{4: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14], 5: [10]}
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
User test case 1:
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 2:
[10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 3:
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 4:
[4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 4, 4, 4, 4]
Code: 16:00:46 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
biggestSquare = 0
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] = squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
print(squares)
if biggestSquare >= h:
return h
return max(squares)
Code: 16:00:49 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
biggestSquare = 0
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] = squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
print(squares)
if biggestSquare >= h:
return h
return max(squares)
Analysis
expand all
Example tests
1.
0.036 s
OK
stdout:
[5, 3, 2, 1]
{1: [0, 4], 2: [1], 5: [2], 3: [3, 5]}
[0, 0, 1, 0, 0, 0]
[0, 0, 2, 2, 0, 0]
[0, 0, 2, 2, 0, 1]
[0, 3, 2, 3, 0, 1]
1.
0.036 s
OK
stdout:
[5, 4, 3]
{3: [0, 1, 2], 5: [3], 4: [4]}
[0, 0, 0, 1, 0]
[0, 0, 0, 2, 2]
[1, 0, 0, 2, 2]
[2, 2, 0, 2, 2]
[5, 2, 3, 2, 5]
1.
0.036 s
OK
stdout:
[6, 5, 2]
{6: [0, 3], 5: [1, 2], 2: [4, 5]}
[1, 0, 0, 0, 0, 0]
[1, 0, 0, 1, 0, 0]
[2, 2, 0, 1, 0, 0]
[4, 2, 3, 4, 0, 0]
expand all
User tests
1.
0.036 s
OK
function result: 2
function result: 2
stdout:
[10]
{10: [0, 1]}
[1, 0]
[2, 2]
1.
0.036 s
OK
function result: 10
function result: 10
stdout:
[10]
{10: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0, 0]
[5, 2, 3, 4, 5, 0, 0, 0, 0, 0]
[6, 2, 3, 4, 5, 6, 0, 0, 0, 0]
[7, 2, 3, 4, 5, 6, 7, 0, 0, 0]
[8, 2, 3, 4, 5, 6, 7, 8, 0, 0]
[9, 2, 3, 4, 5, 6, 7, 8, 9, 0]
[10, 2, 3, 4, 5, 6, 7, 8, 9, 10]
1.
0.036 s
OK
function result: 9
function result: 9
stdout:
[10]
{10: [0, 1, 2, 3, 4, 5, 6, 7, 8]}
[1, 0, 0, 0, 0, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0]
[5, 2, 3, 4, 5, 0, 0, 0, 0]
[6, 2, 3, 4, 5, 6, 0, 0, 0]
[7, 2, 3, 4, 5, 6, 7, 0, 0]
[8, 2, 3, 4, 5, 6, 7, 8, 0]
[9, 2, 3, 4, 5, 6, 7, 8, 9]
1.
0.036 s
OK
function result: 10
function result: 10
stdout:
[10]
{10: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]}
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0]
[5, 2, 3, 4, 5, 0, 0, 0, 0, 0, 0]
[6, 2, 3, 4, 5, 6, 0, 0, 0, 0, 0]
[7, 2, 3, 4, 5, 6, 7, 0, 0, 0, 0]
[8, 2, 3, 4, 5, 6, 7, 8, 0, 0, 0]
[9, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0]
[10, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0]
1.
0.036 s
OK
function result: 4
function result: 4
stdout:
[5, 4]
{4: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14], 5: [10]}
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
User test case 1:
[10, 10]
User test case 2:
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 3:
[10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 4:
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 5:
[4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 4, 4, 4, 4]
Code: 16:01:03 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
biggestSquare = 0
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] = squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
print(squares)
if biggestSquare >= h:
return h
return max(squares)
Analysis
expand all
Example tests
1.
0.036 s
OK
stdout:
[5, 3, 2, 1]
{1: [0, 4], 2: [1], 5: [2], 3: [3, 5]}
[0, 0, 1, 0, 0, 0]
[0, 0, 2, 2, 0, 0]
[0, 0, 2, 2, 0, 1]
[0, 3, 2, 3, 0, 1]
1.
0.036 s
OK
stdout:
[5, 4, 3]
{3: [0, 1, 2], 5: [3], 4: [4]}
[0, 0, 0, 1, 0]
[0, 0, 0, 2, 2]
[1, 0, 0, 2, 2]
[2, 2, 0, 2, 2]
[5, 2, 3, 2, 5]
1.
0.036 s
OK
stdout:
[6, 5, 2]
{6: [0, 3], 5: [1, 2], 2: [4, 5]}
[1, 0, 0, 0, 0, 0]
[1, 0, 0, 1, 0, 0]
[2, 2, 0, 1, 0, 0]
[4, 2, 3, 4, 0, 0]
expand all
User tests
1.
0.036 s
OK
function result: 1
function result: 1
stdout:
[10, 1]
{10: [0, 2], 1: [1]}
[1, 0, 0]
[1, 0, 1]
[3, 2, 3]
1.
0.036 s
OK
function result: 10
function result: 10
stdout:
[10]
{10: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0, 0]
[5, 2, 3, 4, 5, 0, 0, 0, 0, 0]
[6, 2, 3, 4, 5, 6, 0, 0, 0, 0]
[7, 2, 3, 4, 5, 6, 7, 0, 0, 0]
[8, 2, 3, 4, 5, 6, 7, 8, 0, 0]
[9, 2, 3, 4, 5, 6, 7, 8, 9, 0]
[10, 2, 3, 4, 5, 6, 7, 8, 9, 10]
1.
0.036 s
OK
function result: 9
function result: 9
stdout:
[10]
{10: [0, 1, 2, 3, 4, 5, 6, 7, 8]}
[1, 0, 0, 0, 0, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0]
[5, 2, 3, 4, 5, 0, 0, 0, 0]
[6, 2, 3, 4, 5, 6, 0, 0, 0]
[7, 2, 3, 4, 5, 6, 7, 0, 0]
[8, 2, 3, 4, 5, 6, 7, 8, 0]
[9, 2, 3, 4, 5, 6, 7, 8, 9]
1.
0.036 s
OK
function result: 10
function result: 10
stdout:
[10]
{10: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]}
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0]
[5, 2, 3, 4, 5, 0, 0, 0, 0, 0, 0]
[6, 2, 3, 4, 5, 6, 0, 0, 0, 0, 0]
[7, 2, 3, 4, 5, 6, 7, 0, 0, 0, 0]
[8, 2, 3, 4, 5, 6, 7, 8, 0, 0, 0]
[9, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0]
[10, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0]
1.
0.036 s
OK
function result: 4
function result: 4
stdout:
[5, 4]
{4: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14], 5: [10]}
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
User test case 1:
[10, 1, 10]
User test case 2:
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 3:
[10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 4:
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 5:
[4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 4, 4, 4, 4]
Code: 16:01:38 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
biggestSquare = 0
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] = squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
print(squares)
if biggestSquare >= h:
return h
return max(squares)
Code: 16:01:43 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
biggestSquare = 0
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] = squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
print(squares)
if biggestSquare >= h:
return h
return max(squares)
Analysis
expand all
Example tests
1.
0.036 s
OK
stdout:
[5, 3, 2, 1]
{1: [0, 4], 2: [1], 5: [2], 3: [3, 5]}
[0, 0, 1, 0, 0, 0]
[0, 0, 2, 2, 0, 0]
[0, 0, 2, 2, 0, 1]
[0, 3, 2, 3, 0, 1]
1.
0.036 s
OK
stdout:
[5, 4, 3]
{3: [0, 1, 2], 5: [3], 4: [4]}
[0, 0, 0, 1, 0]
[0, 0, 0, 2, 2]
[1, 0, 0, 2, 2]
[2, 2, 0, 2, 2]
[5, 2, 3, 2, 5]
1.
0.036 s
OK
stdout:
[6, 5, 2]
{6: [0, 3], 5: [1, 2], 2: [4, 5]}
[1, 0, 0, 0, 0, 0]
[1, 0, 0, 1, 0, 0]
[2, 2, 0, 1, 0, 0]
[4, 2, 3, 4, 0, 0]
expand all
User tests
1.
0.036 s
OK
function result: 1
function result: 1
stdout:
[10, 2, 1]
{10: [0, 4], 1: [1, 3], 2: [2]}
[1, 0, 0, 0, 0]
[1, 0, 0, 0, 1]
[1, 0, 1, 0, 1]
[3, 2, 3, 0, 1]
1.
0.036 s
OK
function result: 10
function result: 10
stdout:
[10]
{10: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0, 0]
[5, 2, 3, 4, 5, 0, 0, 0, 0, 0]
[6, 2, 3, 4, 5, 6, 0, 0, 0, 0]
[7, 2, 3, 4, 5, 6, 7, 0, 0, 0]
[8, 2, 3, 4, 5, 6, 7, 8, 0, 0]
[9, 2, 3, 4, 5, 6, 7, 8, 9, 0]
[10, 2, 3, 4, 5, 6, 7, 8, 9, 10]
1.
0.036 s
OK
function result: 9
function result: 9
stdout:
[10]
{10: [0, 1, 2, 3, 4, 5, 6, 7, 8]}
[1, 0, 0, 0, 0, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0]
[5, 2, 3, 4, 5, 0, 0, 0, 0]
[6, 2, 3, 4, 5, 6, 0, 0, 0]
[7, 2, 3, 4, 5, 6, 7, 0, 0]
[8, 2, 3, 4, 5, 6, 7, 8, 0]
[9, 2, 3, 4, 5, 6, 7, 8, 9]
1.
0.036 s
OK
function result: 10
function result: 10
stdout:
[10]
{10: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]}
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0]
[5, 2, 3, 4, 5, 0, 0, 0, 0, 0, 0]
[6, 2, 3, 4, 5, 6, 0, 0, 0, 0, 0]
[7, 2, 3, 4, 5, 6, 7, 0, 0, 0, 0]
[8, 2, 3, 4, 5, 6, 7, 8, 0, 0, 0]
[9, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0]
[10, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0]
1.
0.036 s
OK
function result: 4
function result: 4
stdout:
[5, 4]
{4: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14], 5: [10]}
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
User test case 1:
[10, 1, 2, 1, 10]
User test case 2:
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 3:
[10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 4:
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 5:
[4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 4, 4, 4, 4]
Code: 16:01:58 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
biggestSquare = 0
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] = squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
print(squares)
if biggestSquare >= h:
return h
return max(squares)
Analysis
expand all
Example tests
1.
0.036 s
OK
stdout:
[5, 3, 2, 1]
{1: [0, 4], 2: [1], 5: [2], 3: [3, 5]}
[0, 0, 1, 0, 0, 0]
[0, 0, 2, 2, 0, 0]
[0, 0, 2, 2, 0, 1]
[0, 3, 2, 3, 0, 1]
1.
0.036 s
OK
stdout:
[5, 4, 3]
{3: [0, 1, 2], 5: [3], 4: [4]}
[0, 0, 0, 1, 0]
[0, 0, 0, 2, 2]
[1, 0, 0, 2, 2]
[2, 2, 0, 2, 2]
[5, 2, 3, 2, 5]
1.
0.040 s
OK
stdout:
[6, 5, 2]
{6: [0, 3], 5: [1, 2], 2: [4, 5]}
[1, 0, 0, 0, 0, 0]
[1, 0, 0, 1, 0, 0]
[2, 2, 0, 1, 0, 0]
[4, 2, 3, 4, 0, 0]
expand all
User tests
1.
0.036 s
OK
function result: 2
function result: 2
stdout:
[10, 3, 2, 1]
{10: [0, 4], 1: [1], 3: [2], 2: [3]}
[1, 0, 0, 0, 0]
[1, 0, 0, 0, 1]
[1, 0, 1, 0, 1]
[1, 0, 3, 2, 3]
1.
0.036 s
OK
function result: 10
function result: 10
stdout:
[10]
{10: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0, 0]
[5, 2, 3, 4, 5, 0, 0, 0, 0, 0]
[6, 2, 3, 4, 5, 6, 0, 0, 0, 0]
[7, 2, 3, 4, 5, 6, 7, 0, 0, 0]
[8, 2, 3, 4, 5, 6, 7, 8, 0, 0]
[9, 2, 3, 4, 5, 6, 7, 8, 9, 0]
[10, 2, 3, 4, 5, 6, 7, 8, 9, 10]
1.
0.036 s
OK
function result: 9
function result: 9
stdout:
[10]
{10: [0, 1, 2, 3, 4, 5, 6, 7, 8]}
[1, 0, 0, 0, 0, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0]
[5, 2, 3, 4, 5, 0, 0, 0, 0]
[6, 2, 3, 4, 5, 6, 0, 0, 0]
[7, 2, 3, 4, 5, 6, 7, 0, 0]
[8, 2, 3, 4, 5, 6, 7, 8, 0]
[9, 2, 3, 4, 5, 6, 7, 8, 9]
1.
0.040 s
OK
function result: 10
function result: 10
stdout:
[10]
{10: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]}
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0]
[5, 2, 3, 4, 5, 0, 0, 0, 0, 0, 0]
[6, 2, 3, 4, 5, 6, 0, 0, 0, 0, 0]
[7, 2, 3, 4, 5, 6, 7, 0, 0, 0, 0]
[8, 2, 3, 4, 5, 6, 7, 8, 0, 0, 0]
[9, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0]
[10, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0]
1.
0.036 s
OK
function result: 4
function result: 4
stdout:
[5, 4]
{4: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14], 5: [10]}
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
User test case 1:
[10, 1, 3, 2, 10]
User test case 2:
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 3:
[10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 4:
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 5:
[4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 4, 4, 4, 4]
Code: 16:02:11 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
biggestSquare = 0
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] = squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
print(squares)
if biggestSquare >= h:
return h
return max(squares)
Code: 16:02:17 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
print(heights)
print(height_locs)
squares = [0]*len(A)
biggestSquare = 0
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] = squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
print(squares)
if biggestSquare >= h:
return h
return max(squares)
Analysis
expand all
Example tests
1.
0.036 s
OK
stdout:
[5, 3, 2, 1]
{1: [0, 4], 2: [1], 5: [2], 3: [3, 5]}
[0, 0, 1, 0, 0, 0]
[0, 0, 2, 2, 0, 0]
[0, 0, 2, 2, 0, 1]
[0, 3, 2, 3, 0, 1]
1.
0.036 s
OK
stdout:
[5, 4, 3]
{3: [0, 1, 2], 5: [3], 4: [4]}
[0, 0, 0, 1, 0]
[0, 0, 0, 2, 2]
[1, 0, 0, 2, 2]
[2, 2, 0, 2, 2]
[5, 2, 3, 2, 5]
1.
0.036 s
OK
stdout:
[6, 5, 2]
{6: [0, 3], 5: [1, 2], 2: [4, 5]}
[1, 0, 0, 0, 0, 0]
[1, 0, 0, 1, 0, 0]
[2, 2, 0, 1, 0, 0]
[4, 2, 3, 4, 0, 0]
expand all
User tests
1.
0.036 s
OK
function result: 2
function result: 2
stdout:
[2]
{2: [0, 1, 2, 3, 4]}
[1, 0, 0, 0, 0]
[2, 2, 0, 0, 0]
1.
0.036 s
OK
function result: 10
function result: 10
stdout:
[10]
{10: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0, 0]
[5, 2, 3, 4, 5, 0, 0, 0, 0, 0]
[6, 2, 3, 4, 5, 6, 0, 0, 0, 0]
[7, 2, 3, 4, 5, 6, 7, 0, 0, 0]
[8, 2, 3, 4, 5, 6, 7, 8, 0, 0]
[9, 2, 3, 4, 5, 6, 7, 8, 9, 0]
[10, 2, 3, 4, 5, 6, 7, 8, 9, 10]
1.
0.036 s
OK
function result: 9
function result: 9
stdout:
[10]
{10: [0, 1, 2, 3, 4, 5, 6, 7, 8]}
[1, 0, 0, 0, 0, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0]
[5, 2, 3, 4, 5, 0, 0, 0, 0]
[6, 2, 3, 4, 5, 6, 0, 0, 0]
[7, 2, 3, 4, 5, 6, 7, 0, 0]
[8, 2, 3, 4, 5, 6, 7, 8, 0]
[9, 2, 3, 4, 5, 6, 7, 8, 9]
1.
0.036 s
OK
function result: 10
function result: 10
stdout:
[10]
{10: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]}
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0]
[5, 2, 3, 4, 5, 0, 0, 0, 0, 0, 0]
[6, 2, 3, 4, 5, 6, 0, 0, 0, 0, 0]
[7, 2, 3, 4, 5, 6, 7, 0, 0, 0, 0]
[8, 2, 3, 4, 5, 6, 7, 8, 0, 0, 0]
[9, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0]
[10, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0]
1.
0.036 s
OK
function result: 4
function result: 4
stdout:
[5, 4]
{4: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14], 5: [10]}
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[3, 2, 3, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[4, 2, 3, 4, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
User test case 1:
[2, 2, 2, 2, 2]
User test case 2:
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 3:
[10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 4:
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 5:
[4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 4, 4, 4, 4]
Code: 16:02:41 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
squares = [0]*len(A)
biggestSquare = 0
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] = squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
print(squares)
if biggestSquare >= h:
return h
return max(squares)
Code: 16:02:52 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
height_locs = {}
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
squares = [0]*len(A)
biggestSquare = 0
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] = squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
if biggestSquare >= h:
return h
return max(squares)
Code: 16:03:05 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
biggestSquare = 0
height_locs = {}
squares = [0]*len(A)
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
heights = list(set(A))
heights.sort(reverse=True)
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] = squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
if biggestSquare >= h:
return h
return max(squares)
Code: 16:03:16 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
biggestSquare = 0
height_locs = {}
squares = [0]*len(A)
heights = list(set(A))
heights.sort(reverse=True)
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] = squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
if biggestSquare >= h:
return h
return max(squares)
Code: 16:03:24 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
biggestSquare = 0
height_locs = {}
squares = [0]*len(A)
heights = list(set(A))
heights.sort(reverse=True)
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] = squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
if biggestSquare >= h:
return h
return max(squares)
Analysis
User test case 1:
[2, 2, 2, 2, 2]
User test case 2:
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 3:
[10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 4:
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 5:
[4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 4, 4, 4, 4]
Code: 16:03:48 UTC,
py,
autosave
def solution(A):
biggestSquare = 0
height_locs = {}
squares = [0]*len(A)
heights = list(set(A))
heights.sort(reverse=True)
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] = squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
if biggestSquare >= h:
return h
return max(squares)
Code: 16:03:50 UTC,
py,
verify,
result: Passed
def solution(A):
biggestSquare = 0
height_locs = {}
squares = [0]*len(A)
heights = list(set(A))
heights.sort(reverse=True)
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] = squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
if biggestSquare >= h:
return h
return max(squares)
Analysis
User test case 1:
[2, 2, 2, 2, 2]
User test case 2:
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 3:
[10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 4:
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 5:
[4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 4, 4, 4, 4]
Code: 16:05:09 UTC,
py,
verify,
result: Passed
def solution(A):
biggestSquare = 0
height_locs = {}
squares = [0]*len(A)
heights = list(set(A))
heights.sort(reverse=True)
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] = squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
if biggestSquare >= h:
return h
return max(squares)
Analysis
User test case 1:
[2, 2, 2, 2, 2]
User test case 2:
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 3:
[10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 4:
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 5:
[4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 4, 4, 4, 4]
Code: 16:05:16 UTC,
py,
verify,
result: Passed
def solution(A):
biggestSquare = 0
height_locs = {}
squares = [0]*len(A)
heights = list(set(A))
heights.sort(reverse=True)
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] = squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
if biggestSquare >= h:
return h
return max(squares)
Analysis
User test case 1:
[2, 2, 2, 2, 2]
User test case 2:
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 3:
[10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 4:
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
User test case 5:
[4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 4, 4, 4, 4]
Code: 16:05:19 UTC,
py,
final,
score:
100
def solution(A):
biggestSquare = 0
height_locs = {}
squares = [0]*len(A)
heights = list(set(A))
heights.sort(reverse=True)
for i,a in enumerate(A):
if a in height_locs:
height_locs[a].append(i)
else:
height_locs[a] = [i]
for h in heights:
for idx in height_locs[h]:
if biggestSquare > h:
return biggestSquare
squares[idx] = 1
left = squares[idx-1] if idx > 0 else 0
if left > 0:
squares[idx - left] += 1
squares[idx] = squares[idx-left]
right = squares[idx+1] if idx < len(A)-1 else 0
if right > 0:
squares[idx + right] += squares[idx]
squares[idx - left] = squares[idx + right]
if squares[idx - left] >= biggestSquare:
biggestSquare = squares[idx-left]
if biggestSquare >= h:
return h
return max(squares)Analysis summary
The solution obtained perfect score.
Analysis
Detected time complexity:
O(N * log(N)) or O(N)
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
7.
0.044 s
OK
8.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
4.
0.036 s
OK
small_sticking_out_square
Tests with the biggest square surrounded by shorter columns. N <= 10.
Tests with the biggest square surrounded by shorter columns. N <= 10.
✔
OK
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
4.
0.036 s
OK
small_big_and_small_numbers
Tests with alternating small and big numbers (relatively). N <= 15.
Tests with alternating small and big numbers (relatively). N <= 15.
✔
OK
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
medium_few_monotonic_sequences
Two monotonic sequences or one monotonic and one constant. N <= 75.
Two monotonic sequences or one monotonic and one constant. N <= 75.
✔
OK
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
7.
0.036 s
OK
medium_local_maximums_and_local_minimums
Tests with local maximums and local minimums. N <= 75.
Tests with local maximums and local minimums. N <= 75.
✔
OK
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
7.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
expand all
Performance tests
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
4.
0.036 s
OK
5.
0.040 s
OK
6.
0.040 s
OK
1.
0.064 s
OK
2.
0.044 s
OK
3.
0.060 s
OK
4.
0.056 s
OK
1.
0.140 s
OK
2.
0.240 s
OK
3.
0.300 s
OK
4.
0.240 s
OK
5.
0.224 s
OK
6.
0.244 s
OK
7.
0.296 s
OK
8.
0.160 s
OK
9.
0.244 s
OK
10.
0.220 s
OK
11.
0.180 s
OK
12.
0.160 s
OK
13.
0.208 s
OK