Test results - Codility

Tasks Details

medium

1. MaxSquareOnMatrix

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

53%

Correctness

100%

Performance

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

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

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

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

Solution

Programming language used Python

Time spent on task 46 minutes

Notes

not defined yet

Code: 21:11:05 UTC, java, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public int solution(int[] A) {
        // write your code in Java SE 8
    }
}

Code: 21:11:19 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    pass

Code: 21:11:21 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    pass

Analysis

expand all Example tests

▶

example1
First example test.

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.036 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

▶

example2
Second example test.

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.036 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

▶

example3
Third example test.

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.036 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

Code: 21:18:28 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    
    pass

Code: 21:19:34 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    for 
    pass

Code: 21:19:45 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    for i in range(len())
    pass

Code: 21:20:15 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    curre
    for i in range(len())
    pass

Code: 21:20:25 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    for i in range(len())
    pass

Code: 21:21:12 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    for i in range(len(A))
    pass

Code: 21:21:27 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    for i in range(len(A)):
        if 
    pass

Code: 21:21:38 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    for i in range(len(A)):
        
        if 
    pass

Code: 21:21:56 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    for i in range(len(A)):
        cur_matrix = []
        if 
    pass

Code: 21:22:10 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    for i in range(len(A)):
        cur_matrix = []
        cur_column = A[i]
        if 
    pass

Code: 21:22:33 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    for i in range(len(A)):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= 
    pass

Code: 21:22:49 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    for i in range(len(A)):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        
    pass

Code: 21:23:19 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_rows = l
    for i in range(len(A)):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        
    pass

Code: 21:23:36 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_rows = len(A)
    for i in range(matrix_no_rows:
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        
    pass

Code: 21:23:51 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns:
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        
    pass

Code: 21:24:03 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if 
        
    pass

Code: 21:25:12 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if mat
        
    pass

Code: 21:25:22 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i
        
    pass

Code: 21:25:35 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i <
        
    pass

Code: 21:25:47 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        
        
    pass

Code: 21:26:32 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur
        
    pass

Code: 21:26:49 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(A[i])
        
    pass

Code: 21:26:59 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        
    pass

Code: 21:27:09 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        if min()
    pass

Code: 21:27:56 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        if min(cur_m)
    pass

Code: 21:28:10 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        if min(cur_matrix + [])
    pass

Code: 21:28:20 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        if min(cur_matrix + [len()])
    pass

Code: 21:28:38 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        if min(cur_matrix + [len(cur_matrix)]) > cur_
    pass

Code: 21:29:08 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        if min(cur_matrix + [len(cur_matrix)]) > current_max:
            continue
    pass

Code: 21:29:25 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        if min(cur_matrix + [len(cur_matrix)]) > current_max:
            continue
        
    pass

Code: 21:29:55 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        if min(cur_matrix + [len(cur_matrix)]) > current_max:
            
        
    pass

Code: 21:30:05 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        if min(cur_matrix + [len(cur_matrix)]) > current_max:
            current_max
        
    pass

Code: 21:30:19 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        current_square = 
        if min(cur_matrix + [len(cur_matrix)]) > current_max:
            current_max = 
        
    pass

Code: 21:30:40 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        if current_square > current_max:
            current_max = 
        
    pass

Code: 21:30:50 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        if current_square > current_max:
            current_max = current_square
        
    pass

Code: 21:31:17 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        if current_square > current_max:
            current_max = current_square
    return current_max
    
    pass

Code: 21:31:27 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        if current_square > current_max:
            current_max = current_square
            
    return current_max

    pass

Code: 21:31:42 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        if 
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Code: 21:32:05 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        if len(cur_matrix) > 
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Code: 21:32:23 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        if len(cur_matrix) > min(cur_matrix):
            continue
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Code: 21:32:25 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        if len(cur_matrix) > min(cur_matrix):
            continue
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✘

WRONG ANSWER
got 1 expected 2

0.036 s

WRONG ANSWER, got 1 expected 2

▶

example2
Second example test.

✘

WRONG ANSWER
got 1 expected 3

0.036 s

WRONG ANSWER, got 1 expected 3

▶

example3
Third example test.

✘

WRONG ANSWER
got 1 expected 4

0.036 s

WRONG ANSWER, got 1 expected 4

Code: 21:32:52 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        print(current_square)
        if len(cur_matrix) > min(cur_matrix):
            continue
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✘

WRONG ANSWER
got 1 expected 2

0.036 s

WRONG ANSWER, got 1 expected 2

stdout:

▶

example2
Second example test.

✘

WRONG ANSWER
got 1 expected 3

0.036 s

WRONG ANSWER, got 1 expected 3

stdout:

▶

example3
Third example test.

✘

WRONG ANSWER
got 1 expected 4

0.036 s

WRONG ANSWER, got 1 expected 4

stdout:

Code: 21:33:13 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        print(cur_matrix + [len(cur_matrix)])
        if len(cur_matrix) > min(cur_matrix):
            continue
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Code: 21:33:13 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        print(cur_matrix + [len(cur_matrix)])
        if len(cur_matrix) > min(cur_matrix):
            continue
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✘

WRONG ANSWER
got 1 expected 2

0.036 s

WRONG ANSWER, got 1 expected 2

stdout:

[1, 1]
[2, 1]
[5, 1]
[3, 1]
[3, 1]

▶

example2
Second example test.

✘

WRONG ANSWER
got 1 expected 3

0.036 s

WRONG ANSWER, got 1 expected 3

stdout:

[3, 1]
[3, 1]
[3, 1]
[5, 1]
[4, 1]

▶

example3
Third example test.

✘

WRONG ANSWER
got 1 expected 4

0.036 s

WRONG ANSWER, got 1 expected 4

stdout:

[6, 1]
[5, 1]
[5, 1]
[6, 1]
[2, 1]
[2, 1]

Code: 21:34:38 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        print(cur_matrix + [len(cur_matrix)])
        if len(cur_matrix) > min(cur_matrix) :
            continue
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Code: 21:34:40 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        print(cur_matrix + [len(cur_matrix)])
        if len(cur_matrix) > min(cur_matrix) + 1:
            continue
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✘

WRONG ANSWER
got 1 expected 2

0.036 s

WRONG ANSWER, got 1 expected 2

stdout:

[1, 1]
[2, 1]
[5, 1]
[3, 1]
[3, 1]

▶

example2
Second example test.

✘

WRONG ANSWER
got 1 expected 3

0.036 s

WRONG ANSWER, got 1 expected 3

stdout:

[3, 1]
[3, 1]
[3, 1]
[5, 1]
[4, 1]

▶

example3
Third example test.

✘

WRONG ANSWER
got 1 expected 4

0.036 s

WRONG ANSWER, got 1 expected 4

stdout:

[6, 1]
[5, 1]
[5, 1]
[6, 1]
[2, 1]
[2, 1]

Code: 21:35:56 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        print(cur_matrix + [len(cur_matrix)])
        if len(cur_matrix) > min(cur_matrix) + :
            continue
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Code: 21:36:02 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        print(cur_matrix + [len(cur_matrix)])
        # if len(cur_matrix) > min(cur_matrix):
        #     continue
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✘

WRONG ANSWER
got 1 expected 2

0.036 s

WRONG ANSWER, got 1 expected 2

stdout:

[1, 1]
[2, 1]
[5, 1]
[3, 1]
[3, 1]

▶

example2
Second example test.

✘

WRONG ANSWER
got 1 expected 3

0.036 s

WRONG ANSWER, got 1 expected 3

stdout:

[3, 1]
[3, 1]
[3, 1]
[5, 1]
[4, 1]

▶

example3
Third example test.

✘

WRONG ANSWER
got 1 expected 4

0.036 s

WRONG ANSWER, got 1 expected 4

stdout:

[6, 1]
[5, 1]
[5, 1]
[6, 1]
[2, 1]
[2, 1]

Code: 21:36:33 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        # if matrix_no_columns - i < current_max:
        #     break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        print(cur_matrix + [len(cur_matrix)])
        # if len(cur_matrix) > min(cur_matrix):
        #     continue
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Code: 21:36:34 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        # if matrix_no_columns - i < current_max:
        #     break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        print(cur_matrix + [len(cur_matrix)])
        # if len(cur_matrix) > min(cur_matrix):
        #     continue
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✘

WRONG ANSWER
got 1 expected 2

0.036 s

WRONG ANSWER, got 1 expected 2

stdout:

[1, 1]
[2, 1]
[5, 1]
[3, 1]
[3, 1]

▶

example2
Second example test.

✘

WRONG ANSWER
got 1 expected 3

0.036 s

WRONG ANSWER, got 1 expected 3

stdout:

[3, 1]
[3, 1]
[3, 1]
[5, 1]
[4, 1]

▶

example3
Third example test.

✘

WRONG ANSWER
got 1 expected 4

0.036 s

WRONG ANSWER, got 1 expected 4

stdout:

[6, 1]
[5, 1]
[5, 1]
[6, 1]
[2, 1]
[2, 1]

Code: 21:36:45 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
        cur_matrix = []
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        print(cur_matrix + [len(cur_matrix)])
        # if len(cur_matrix) > min(cur_matrix):
        #     continue
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Code: 21:38:05 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    for i in range(matrix_no_columns):
x        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        print(cur_matrix + [len(cur_matrix)])
        # if len(cur_matrix) > min(cur_matrix):
        #     continue
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Code: 21:38:11 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix + [len(cur_matrix)]
    for i in range(matrix_no_columns):
x        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        print(cur_matrix + [len(cur_matrix)])
        # if len(cur_matrix) > min(cur_matrix):
        #     continue
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.036 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Traceback (most recent call last):
  File "exec.py", line 129, in <module>
    main()
  File "exec.py", line 70, in main
    sol = __import__('solution')
  File "/tmp/solution.py", line 10
    x        cur_column = A[i]
    ^
IndentationError: expected an indented block

▶

example2
Second example test.

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.036 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Traceback (most recent call last):
  File "exec.py", line 129, in <module>
    main()
  File "exec.py", line 70, in main
    sol = __import__('solution')
  File "/tmp/solution.py", line 10
    x        cur_column = A[i]
    ^
IndentationError: expected an indented block

▶

example3
Third example test.

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.036 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Traceback (most recent call last):
  File "exec.py", line 129, in <module>
    main()
  File "exec.py", line 70, in main
    sol = __import__('solution')
  File "/tmp/solution.py", line 10
    x        cur_column = A[i]
    ^
IndentationError: expected an indented block

Code: 21:38:35 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A
    for i in range(matrix_no_columns):
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        print(cur_matrix + [len(cur_matrix)])
        # if len(cur_matrix) > min(cur_matrix):
        #     continue
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Code: 21:38:40 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        print(cur_matrix + [len(cur_matrix)])
        # if len(cur_matrix) > min(cur_matrix):
        #     continue
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✘

WRONG ANSWER
got 1 expected 2

0.056 s

WRONG ANSWER, got 1 expected 2

stdout:

[1, 1]
[1, 2, 2]
[1, 2, 5, 3]
[1, 2, 5, 3, 4]
[1, 2, 5, 3, 3, 5]

▶

example2
Second example test.

✔

0.036 s

stdout:

[3, 1]
[3, 3, 2]
[3, 3, 3, 3]

▶

example3
Third example test.

✔

0.036 s

stdout:

[6, 1]
[6, 5, 2]
[6, 5, 5, 3]
[6, 5, 5, 6, 4]

Code: 21:39:05 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        cur_column = A[i]
        if cur_column <= current_max:
            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        print(cur_matrix + [len(cur_matrix)])
        if len(cur_matrix) > min(cur_matrix):
            
            continue
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Code: 21:39:22 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        cur_column = A[i]
        if cur_column <= current_max:
            cur_matrix = []

            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        print(cur_matrix + [len(cur_matrix)])
        if len(cur_matrix) > min(cur_matrix):
            cur_matrix = []

            continue
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

stdout:

[1, 1]
[1, 2, 2]
[5, 1]
[5, 3, 2]

▶

example2
Second example test.

✔

0.036 s

stdout:

[3, 1]
[3, 3, 2]
[3, 3, 3, 3]

▶

example3
Third example test.

✔

0.036 s

stdout:

[6, 1]
[6, 5, 2]
[6, 5, 5, 3]
[6, 5, 5, 6, 4]

Code: 21:39:53 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        cur_column = A[i]
        if cur_column <= current_max:
            cur_matrix = []

            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        if len(cur_matrix) > min(cur_matrix):
            cur_matrix = []

            continue
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Code: 21:40:01 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        cur_column = A[i]
        if cur_column <= current_max:
            cur_matrix = []

            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        if len(cur_matrix) > min(cur_matrix):
            cur_matrix = []

            continue
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

Code: 21:40:41 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        cur_column = A[i]
        if cur_column <= current_max:
            cur_matrix = []

            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        if len(cur_matrix) > min(cur_matrix):
            cur_matrix = []

            continue
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Code: 21:40:47 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        cur_column = A[i]
        if cur_column <= current_max:
            cur_matrix = []

            continue
        if matrix_no_columns - i < current_max:
            break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        if len(cur_matrix) > min(cur_matrix):
            cur_matrix = []

            continue
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 3

User test case 1:

[1, 2, 3, 4, 5, 6, 7, 8, 9]

Code: 21:42:08 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        cur_column = A[i]
        if cur_column <= current_max:
            cur_matrix = []

            continue
        # if matrix_no_columns - i < current_max:
        #     break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        if len(cur_matrix) > min(cur_matrix):
            cur_matrix = []

            continue
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Code: 21:42:08 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        cur_column = A[i]
        if cur_column <= current_max:
            cur_matrix = []

            continue
        # if matrix_no_columns - i < current_max:
        #     break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        if len(cur_matrix) > min(cur_matrix):
            cur_matrix = []

            continue
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 3

User test case 1:

[1, 2, 3, 4, 5, 6, 7, 8, 9]

Code: 21:44:42 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        
        cur_column = A[i]
        if cur_column <= current_max:
            cur_matrix = []

            continue
        # if matrix_no_columns - i < current_max:
        #     break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        if len(cur_matrix) > min(cur_matrix):
            cur_matrix = []

            continue
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Code: 21:44:53 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        for j in range()
        cur_column = A[i]
        if cur_column <= current_max:
            cur_matrix = []

            continue
        # if matrix_no_columns - i < current_max:
        #     break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        if len(cur_matrix) > min(cur_matrix):
            cur_matrix = []

            continue
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Code: 21:45:11 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        for j in range(i, matrix_no_columns)
        cur_column = A[i]
        if cur_column <= current_max:
            cur_matrix = []

            continue
        # if matrix_no_columns - i < current_max:
        #     break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        if len(cur_matrix) > min(cur_matrix):
            cur_matrix = []

            continue
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Code: 21:45:26 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        for j in range(i, matrix_no_columns):
        cur_column = A[i]
        if cur_column <= current_max:
            cur_matrix = []

            continue
        # if matrix_no_columns - i < current_max:
        #     break
        cur_matrix.append(cur_column)
        current_square = min(cur_matrix + [len(cur_matrix)])
        if len(cur_matrix) > min(cur_matrix):
            cur_matrix = []

            continue
        if current_square > current_max:
            current_max = current_square

    return current_max

    pass

Code: 21:45:37 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        for j in range(i, matrix_no_columns):
            cur_column = A[i]
            if cur_column <= current_max:
                cur_matrix = []

                continue
            # if matrix_no_columns - i < current_max:
            #     break
            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                cur_matrix = []

                continue
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Code: 21:45:49 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                cur_matrix = []

                continue
            # if matrix_no_columns - i < current_max:
            #     break
            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                cur_matrix = []

                continue
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Code: 21:46:05 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        cur_matrix = [A]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[i]
            if cur_column <= current_max:
                cur_matrix = []

                continue
            # if matrix_no_columns - i < current_max:
            #     break
            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                cur_matrix = []

                continue
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Code: 21:46:15 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[i]
            if cur_column <= current_max:
                cur_matrix = []

                continue
            # if matrix_no_columns - i < current_max:
            #     break
            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                cur_matrix = []

                continue
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Code: 21:46:25 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                cur_matrix = []

                continue
            # if matrix_no_columns - i < current_max:
            #     break
            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                cur_matrix = []

                continue
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Code: 21:46:39 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                cur_matrix = []

                continue
            # if matrix_no_columns - i < current_max:
            #     break
            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                cur_matrix = []

                continue
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.040 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 5

User test case 1:

[1, 2, 3, 4, 5, 6, 7, 8, 9]

Code: 21:46:51 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                cur_matrix = []

                continue
            if matrix_no_columns - i < current_max:
                break
            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                cur_matrix = []

                continue
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 5

User test case 1:

[1, 2, 3, 4, 5, 6, 7, 8, 9]

Code: 21:47:11 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                cur_matrix = []

                continue
x
            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                cur_matrix = []

                continue
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Code: 21:47:24 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
                    if matrix_no_columns - i < current_max:
                break
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                cur_matrix = []

                continue

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                cur_matrix = []

                continue
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Code: 21:47:28 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                cur_matrix = []

                continue

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                cur_matrix = []

                continue
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 5

User test case 1:

[1, 2, 3, 4, 5, 6, 7, 8, 9]

Code: 21:47:40 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                cur_matrix = []

                continue

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                cur_matrix = []

                continue
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 5

User test case 1:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 8]

Code: 21:47:53 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                cur_matrix = []

                continue

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                cur_matrix = []

                continue
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 6

User test case 1:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 8]

Code: 21:48:02 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                cur_matrix = []

                continue

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                cur_matrix = []

                continue
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Code: 21:48:03 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                cur_matrix = []

                continue

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                cur_matrix = []

                continue
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 6

User test case 1:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 8, 1]

Code: 21:48:09 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                cur_matrix = []

                continue

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                cur_matrix = []

                continue
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 6

User test case 1:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 8, 1, 9]

Code: 21:48:16 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                cur_matrix = []

                continue

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                cur_matrix = []

                continue
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.040 s

▶

example2
Second example test.

✔

0.040 s

▶

example3
Third example test.

✔

0.040 s

expand all User tests

▶

test_data1

✔

0.040 s

OK
function result: 7

User test case 1:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 8, 1, 9, 9, 9, 9, 9, 9, 9]

Code: 21:48:22 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                cur_matrix = []

                continue

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                cur_matrix = []

                continue
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 0

User test case 1:

[0]

Code: 21:48:29 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                cur_matrix = []

                continue

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                cur_matrix = []

                continue
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 0

User test case 1:

[1]

Code: 21:48:44 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max :
            break
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                cur_matrix = []

                continue

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                cur_matrix = []

                continue
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Code: 21:48:46 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max + 1:
            break
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                cur_matrix = []

                continue

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                cur_matrix = []

                continue
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 0

User test case 1:

[1]

Code: 21:48:58 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max + 1:
            break
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                cur_matrix = []

                continue

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                cur_matrix = []

                continue
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 0

User test case 1:

[0, 1]

Code: 21:49:05 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max + 1:
            break
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                cur_matrix = []

                continue

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                cur_matrix = []

                continue
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 1

User test case 1:

[1, 0, 1]

Code: 21:49:11 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max + 1:
            break
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                cur_matrix = []

                continue

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                cur_matrix = []

                continue
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.040 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 0

User test case 1:

[1, 0]

Code: 21:49:57 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max + 1:
            break
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                continue

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                cur_matrix = []

                continue
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Code: 21:50:00 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max + 1:
            break
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                continue

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                # cur_matrix = []

                continue
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✘

WRONG ANSWER
got 3 expected 2

0.036 s

WRONG ANSWER, got 3 expected 2

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.040 s

OK
function result: 0

User test case 1:

[1, 0]

Code: 21:50:13 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max + 1:
            break
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                cur_matrix = []

                continue

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                cur_matrix = []

                continue
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 0

User test case 1:

[1, 0]

Code: 21:50:32 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max + 1:
            break
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                cur_matrix = []

                continue
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Code: 21:50:36 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max + 1:
            break
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 0

User test case 1:

[1, 0]

Code: 21:50:51 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i + 1< current_max:
            break
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.040 s

▶

example3
Third example test.

✔

0.056 s

expand all User tests

▶

test_data1

✔

0.040 s

OK
function result: 0

User test case 1:

[1, 0]

Code: 21:51:00 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Code: 21:51:22 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                # cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 0

User test case 1:

[1, 0]

Code: 21:51:33 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                # cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Code: 21:51:34 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                # cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 0

User test case 1:

[1, 1, 0]

Code: 21:51:39 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                # cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 0

User test case 1:

[1, 10]

Code: 21:52:07 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                # cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Code: 21:52:17 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                # cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Code: 21:52:43 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        if A[1] > 0:
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                # cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Code: 21:53:13 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        if A[1] > 0 and current_max == 0:
            
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                # cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Code: 21:53:23 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        if A[1] > 0 and current_max == 0:
            current_max
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                # cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Code: 21:53:27 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        if A[1] > 0 and current_max == 0:
            current_max = 1
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                # cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 1

User test case 1:

[1, 10]

Code: 21:53:35 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        if A[1] > 0 and current_max == 0:
            current_max = 1
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                # cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 2

User test case 1:

[2, 10]

Code: 21:53:40 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        if A[1] > 0 and current_max == 0:
            current_max = 1
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                # cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 2

User test case 1:

[5, 10]

Code: 21:54:02 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        if A[1] > 0 and current_max == 0:
            current_max = 1
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                # cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Code: 21:54:05 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        if A[1] > 0 and current_max == 0:
            current_max = 1
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                # cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.056 s

▶

example2
Second example test.

✔

0.056 s

▶

example3
Third example test.

✔

0.056 s

expand all User tests

▶

test_data1

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.056 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Traceback (most recent call last):
  File "exec.py", line 129, in <module>
    main()
  File "exec.py", line 91, in main
    result = solution( A )
  File "/tmp/solution.py", line 14, in solution
    if A[1] > 0 and current_max == 0:
IndexError: list index out of range

User test case 1:

[10]

Code: 21:54:35 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        if Ai1] > 0 and current_max == 0:
            current_max = 1
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                # cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Code: 21:54:44 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        if A[i] > 0 and current_max == 0:
            current_max = 1
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                # cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 1

User test case 1:

[10]

Code: 21:54:52 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        if A[i] > 0 and current_max == 0:
            current_max = 1
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                # cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 1

User test case 1:

[1]

Code: 21:54:57 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        if A[i] > 0 and current_max == 0:
            current_max = 1
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                # cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 0

User test case 1:

[0]

Code: 21:55:02 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        if A[i] > 0 and current_max == 0:
            current_max = 1
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                # cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 1

User test case 1:

[0, 1]

Code: 21:55:07 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        if A[i] > 0 and current_max == 0:
            current_max = 1
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                # cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Code: 21:55:11 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        if A[i] > 0 and current_max == 0:
            current_max = 1
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                # cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 2

User test case 1:

[0, 2, 2]

Code: 21:55:18 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        if A[i] > 0 and current_max == 0:
            current_max = 1
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                # cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 3

User test case 1:

[0, 3, 3, 3]

Code: 21:55:27 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        if A[i] > 0 and current_max == 0:
            current_max = 1
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                # cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 3

User test case 1:

[3, 3, 3, 0]

Code: 21:55:34 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        if A[i] > 0 and current_max == 0:
            current_max = 1
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                # cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 3

User test case 1:

[3, 3, 4, 0]

Code: 21:55:39 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        if A[i] > 0 and current_max == 0:
            current_max = 1
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                # cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Code: 21:55:39 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        if A[i] > 0 and current_max == 0:
            current_max = 1
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                # cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 3

User test case 1:

[3, 3, 4, 0, 2, 2]

Code: 21:55:48 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        if A[i] > 0 and current_max == 0:
            current_max = 1
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                # cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 3

User test case 1:

[3, 3, 4, 0, 2, 2, 2, 2, 2]

Code: 21:55:56 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        if A[i] > 0 and current_max == 0:
            current_max = 1
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:
                # cur_matrix = []

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):
                # cur_matrix = []

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 5

User test case 1:

[3, 3, 4, 0, 5, 5, 5, 5, 5]

Code: 21:56:08 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        if A[i] > 0 and current_max == 0:
            current_max = 1
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Code: 21:56:19 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        if A[i] > 0 and current_max == 0:
            current_max = 1
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 0

User test case 1:

[]

Code: 21:56:38 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        if A[i] > 0 and current_max == 0:
            current_max = 1
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 0

User test case 1:

[]

Code: 21:56:41 UTC, py, final, score: 53

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A):
    # write your code in Python 3.6
    current_max = 0
    matrix_no_columns = len(A)
    cur_matrix = []

    for i in range(matrix_no_columns):
        if matrix_no_columns - i < current_max:
            break
        cur_matrix = [A[i]]
        if A[i] > 0 and current_max == 0:
            current_max = 1
        for j in range(i+1, matrix_no_columns):
            cur_column = A[j]
            if cur_column <= current_max:

                break

            cur_matrix.append(cur_column)
            current_square = min(cur_matrix + [len(cur_matrix)])
            if len(cur_matrix) > min(cur_matrix):

                break
            if current_square > current_max:
                current_max = current_square

    return current_max

    pass

Analysis summary

The following issues have been detected: timeout errors.

Analysis

Detected time complexity:

O(N ** 3) or O(N ** 5) or O(N ** 2 * log(N)) or O(N ** 4) or O(N ** 2)

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all Correctness tests

▶

small_corner_cases
Small corner cases. N <= 7.

✔

0.036 s

▶

small_all_distinct_or_all_equal
All numbers are distinct or all are equal. N <= 10.

✔

0.036 s

▶

small_sticking_out_square
Tests with the biggest square surrounded by shorter columns. N <= 10.

✔

0.036 s

▶

small_big_and_small_numbers
Tests with alternating small and big numbers (relatively). N <= 15.

✔

0.036 s

▶

medium_few_monotonic_sequences
Two monotonic sequences or one monotonic and one constant. N <= 75.

✔

0.036 s

▶

medium_local_maximums_and_local_minimums
Tests with local maximums and local minimums. N <= 75.

✔

0.036 s

▶

medium_pyramids
Tests in a form of a three-level pyramid. N <= 75.

✔

0.036 s

expand all Performance tests

▶

big_monotonic_sequences
Various combinations of monotonic and constant sequences. N <= 750.

✘

TIMEOUT ERROR
running time: 0.176 sec., time limit: 0.144 sec.

0.176 s

TIMEOUT ERROR, running time: 0.176 sec., time limit: 0.144 sec.

0.164 s

TIMEOUT ERROR, running time: 0.164 sec., time limit: 0.144 sec.

1.080 s

TIMEOUT ERROR, running time: 1.080 sec., time limit: 0.144 sec.

1.060 s

TIMEOUT ERROR, running time: 1.060 sec., time limit: 0.160 sec.

0.064 s

0.068 s

▶

big_random
Randomly generated tests. N <= 10,000. Score x 2.

✘

TIMEOUT ERROR
running time: 1.252 sec., time limit: 0.256 sec.

1.252 s

TIMEOUT ERROR, running time: 1.252 sec., time limit: 0.256 sec.

0.044 s

6.000 s

TIMEOUT ERROR, Killed. Hard limit reached: 6.000 sec.

0.780 s

TIMEOUT ERROR, running time: 0.780 sec., time limit: 0.256 sec.

▶

very_big_all_types
Mixed tests. Score x 3.

✘

TIMEOUT ERROR
Killed. Hard limit reached: 7.000 sec.

0.200 s

7.000 s