Tasks Details
medium
Given a 3x3 matrix, find the nearest matrix, the sum of whose elements in each row and column is equal.
Task Score
100%
Correctness
100%
Performance
100%
You are given a matrix, consisting of three rows and three columns, represented as an array A of nine integers. The rows of the matrix are numbered from 0 to 2 (from top to bottom) and the columns are numbered from 0 to 2 (from left to right). The matrix element in the J-th row and K-th column corresponds to the array element A[J*3 + K]. For example, the matrix below corresponds to array [0, 2, 3, 4, 1, 1, 1, 3, 1].
![[0 2 3]
[4 1 1]
[1 3 1]](https://codility-frontend-prod.s3.amazonaws.com/media/task_static/almost_magic_square/static/images/auto/90a1e1ad6a523c680991ddd2d7fdf063.png)
In one move you can increment any element by 1.
Your task is to find a matrix whose elements in each row and each column sum to an equal value, which can be constructed from the given matrix in a minimal number of moves.
Write a function:
def solution(A)
that, given an array A of nine integers, returns an array of nine integers, representing the matrix described above. If there are several possible answers, the function may return any of them.
Examples:
1. Given A = [0, 2, 3, 4, 1, 1, 1, 3, 1], the function could return [1, 2, 3, 4, 1, 1, 1, 3, 2]. The sum of elements in each row and each column of the returned matrix is 6. Two increments by 1 are enough. You can increment A[0] and A[8] (top-left and bottom-right matrix elements). This gives [1, 2, 3, 4, 1, 1, 1, 3, 2], which satisfies the statement's conditions. Alternatively, you can increment A[2] and A[6] (top-right and bottom-left matrix elements). This gives another correct solution: [0, 2, 4, 4, 1, 1, 2, 3, 1].
![[0 2 3]
[4 1 1]
[1 3 1]](https://codility-frontend-prod.s3.amazonaws.com/media/task_static/almost_magic_square/static/images/auto/01335d3771bd0219656f4c4d593af79c.png)
![[0 2 3]
[4 1 1]
[1 3 1]](https://codility-frontend-prod.s3.amazonaws.com/media/task_static/almost_magic_square/static/images/auto/7515378444fd22edb650da0bfadcf67e.png)
2. Given A = [1, 1, 1, 2, 2, 1, 2, 2, 1], the function should return [1, 1, 3, 2, 2, 1, 2, 2, 1]. The sum of elements in each row and each column of the returned matrix is 5. Two increments by 1 are enough. You can increment A[2] (top-right matrix element) twice. In this case, there are no other correct solutions.
![[1 1 1]
[2 2 1]
[2 2 1]](https://codility-frontend-prod.s3.amazonaws.com/media/task_static/almost_magic_square/static/images/auto/4c283f4b5062ed7b1a43a584f36328c7.png)
Write an efficient algorithm for the following assumptions:
- array A contains nine elements;
- each element of array A is an integer within the range [0..100,000,000].
Copyright 2009–2025 by Codility Limited.
All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Solution
Programming language used Python
Time spent on task 25 minutes
Notes
not defined yet
Code: 19:44:35 UTC,
java,
autosave
Code: 19:49:57 UTC,
py,
autosave
Code: 19:50:26 UTC,
py,
autosave
# 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
abc = A[0] + A[1] + A[2]
dwf = A[3] + A[4] + A[5]
ghi = A[6] + A[7] + A[8]
adg = A[0] + A[3] + A[6]
beh = A[1] + A[4] + A[7]
cfi = A[2] + A[5] + A[8]
Code: 19:50:55 UTC,
py,
autosave
# 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
abc = A[0] + A[1] + A[2]
dwf = A[3] + A[4] + A[5]
ghi = A[6] + A[7] + A[8]
adg = A[0] + A[3] + A[6]
beh = A[1] + A[4] + A[7]
cfi = A[2] + A[5] + A[8]
avg = sum(abc + dwf + ghi + adg + beh + cfi) / 6
Code: 19:54:38 UTC,
py,
autosave
# 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
abc = A[0] + A[1] + A[2]
dwf = A[3] + A[4] + A[5]
ghi = A[6] + A[7] + A[8]
adg = A[0] + A[3] + A[6]
beh = A[1] + A[4] + A[7]
cfi = A[2] + A[5] + A[8]
total = sum(abc + dwf + ghi + adg + beh + cfi) / 6
Code: 19:54:51 UTC,
py,
autosave
# 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
abc = A[0] + A[1] + A[2]
dwf = A[3] + A[4] + A[5]
ghi = A[6] + A[7] + A[8]
adg = A[0] + A[3] + A[6]
beh = A[1] + A[4] + A[7]
cfi = A[2] + A[5] + A[8]
total = sum(abc + dwf + ghi + adg + beh + cfi)
target = int(total / 6) + 1 if total % 6 else total // 6
Code: 20:00:44 UTC,
py,
autosave
# 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\
abc = A[0] + A[1] + A[2]
dwf = A[3] + A[4] + A[5]
ghi = A[6] + A[7] + A[8]
adg = A[0] + A[3] + A[6]
beh = A[1] + A[4] + A[7]
cfi = A[2] + A[5] + A[8]
total = sum(abc + dwf + ghi + adg + beh + cfi)
target = int(total / 6) + 1 if total % 6 else total // 6
Code: 20:01:09 UTC,
py,
autosave
# 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
def row(i):
return A[i * 3] + A[i * 3 + 1] + A[i * 3 + 2]
def col(i):
return A[i] + A[(i + 3) % 9]
abc = A[0] + A[1] + A[2]
dwf = A[3] + A[4] + A[5]
ghi = A[6] + A[7] + A[8]
adg = A[0] + A[3] + A[6]
beh = A[1] + A[4] + A[7]
cfi = A[2] + A[5] + A[8]
total = sum(abc + dwf + ghi + adg + beh + cfi)
target = int(total / 6) + 1 if total % 6 else total // 6
Code: 20:01:39 UTC,
py,
autosave
# 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
def row(i):
return A[i * 3] + A[i * 3 + 1] + A[i * 3 + 2]
def col(i):
return A[i] + A[i + 3] + A[i + 6]
abc = A[0] + A[1] + A[2]
dwf = A[3] + A[4] + A[5]
ghi = A[6] + A[7] + A[8]
adg = A[0] + A[3] + A[6]
beh = A[1] + A[4] + A[7]
cfi = A[2] + A[5] + A[8]
total = sum(abc + dwf + ghi + adg + beh + cfi)
target = int(total / 6) + 1 if total % 6 else total // 6
Code: 20:02:09 UTC,
py,
autosave
# 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
def row(i):
return A[i * 3] + A[i * 3 + 1] + A[i * 3 + 2]
def col(i):
return A[i] + A[i + 3] + A[i + 6]
abc = A[0] + A[1] + A[2]
dwf = A[3] + A[4] + A[5]
ghi = A[6] + A[7] + A[8]
adg = A[0] + A[3] + A[6]
beh = A[1] + A[4] + A[7]
cfi = A[2] + A[5] + A[8]
total = sum(abc + dwf + ghi + adg + beh + cfi)
target = int(total / 6) + 1 if total % 6 else total // 6
A[0] += min(target - row(0), target - col(0))
A[1] += min(target - row(0), target - col(1))
A[2] += min(target - row(0), target - col(2))
A[3] += min(target - row(0), target - col(0))
A[4] += min(target - row(0), target - col(1))
A[5] += min(target - row(0), target - col(2))
A[6] += min(target - row(0), target - col(0))
A[7] += min(target - row(0), target - col(1))
A[8] += min(target - row(0), target - col(2))
Code: 20:02:19 UTC,
py,
autosave
# 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
def row(i):
return A[i * 3] + A[i * 3 + 1] + A[i * 3 + 2]
def col(i):
return A[i] + A[i + 3] + A[i + 6]
abc = A[0] + A[1] + A[2]
dwf = A[3] + A[4] + A[5]
ghi = A[6] + A[7] + A[8]
adg = A[0] + A[3] + A[6]
beh = A[1] + A[4] + A[7]
cfi = A[2] + A[5] + A[8]
total = sum(abc + dwf + ghi + adg + beh + cfi)
target = int(total / 6) + 1 if total % 6 else total // 6
A[0] += min(target - row(0), target - col(0))
A[1] += min(target - row(0), target - col(1))
A[2] += min(target - row(0), target - col(2))
A[3] += min(target - row(1), target - col(0))
A[4] += min(target - row(1), target - col(1))
A[5] += min(target - row(1), target - col(2))
A[6] += min(target - row(2), target - col(0))
A[7] += min(target - row(2), target - col(1))
A[8] += min(target - row(2), target - col(2))
return A
Code: 20:02:24 UTC,
py,
verify,
result: Failed
# 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
def row(i):
return A[i * 3] + A[i * 3 + 1] + A[i * 3 + 2]
def col(i):
return A[i] + A[i + 3] + A[i + 6]
abc = A[0] + A[1] + A[2]
dwf = A[3] + A[4] + A[5]
ghi = A[6] + A[7] + A[8]
adg = A[0] + A[3] + A[6]
beh = A[1] + A[4] + A[7]
cfi = A[2] + A[5] + A[8]
total = sum(abc + dwf + ghi + adg + beh + cfi)
target = int(total / 6) + 1 if total % 6 else total // 6
A[0] += min(target - row(0), target - col(0))
A[1] += min(target - row(0), target - col(1))
A[2] += min(target - row(0), target - col(2))
A[3] += min(target - row(1), target - col(0))
A[4] += min(target - row(1), target - col(1))
A[5] += min(target - row(1), target - col(2))
A[6] += min(target - row(2), target - col(0))
A[7] += min(target - row(2), target - col(1))
A[8] += min(target - row(2), target - col(2))
return A
Analysis
expand all
Example tests
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 141, in <module>
main()
File "exec.py", line 103, in main
result = solution( A )
File "/tmp/solution.py", line 16, in solution
total = sum(abc + dwf + ghi + adg + beh + cfi)
TypeError: 'int' object is not iterable
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 141, in <module>
main()
File "exec.py", line 103, in main
result = solution( A )
File "/tmp/solution.py", line 16, in solution
total = sum(abc + dwf + ghi + adg + beh + cfi)
TypeError: 'int' object is not iterable
Code: 20:02:32 UTC,
py,
verify,
result: Passed
# 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
def row(i):
return A[i * 3] + A[i * 3 + 1] + A[i * 3 + 2]
def col(i):
return A[i] + A[i + 3] + A[i + 6]
abc = A[0] + A[1] + A[2]
dwf = A[3] + A[4] + A[5]
ghi = A[6] + A[7] + A[8]
adg = A[0] + A[3] + A[6]
beh = A[1] + A[4] + A[7]
cfi = A[2] + A[5] + A[8]
total = abc + dwf + ghi + adg + beh + cfi
target = int(total / 6) + 1 if total % 6 else total // 6
A[0] += min(target - row(0), target - col(0))
A[1] += min(target - row(0), target - col(1))
A[2] += min(target - row(0), target - col(2))
A[3] += min(target - row(1), target - col(0))
A[4] += min(target - row(1), target - col(1))
A[5] += min(target - row(1), target - col(2))
A[6] += min(target - row(2), target - col(0))
A[7] += min(target - row(2), target - col(1))
A[8] += min(target - row(2), target - col(2))
return A
Analysis
Code: 20:02:46 UTC,
py,
autosave
# 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
def row(i):
return A[i * 3] + A[i * 3 + 1] + A[i * 3 + 2]
def col(i):
return A[i] + A[i + 3] + A[i + 6]
abc = A[0] + A[1] + A[2]
dwf = A[3] + A[4] + A[5]
ghi = A[6] + A[7] + A[8]
adg = A[0] + A[3] + A[6]
beh = A[1] + A[4] + A[7]
cfi = A[2] + A[5] + A[8]
total =
total = abc + dwf + ghi + adg + beh + cfi
target = int(total / 6) + 1 if total % 6 else total // 6
A[0] += min(target - row(0), target - col(0))
A[1] += min(target - row(0), target - col(1))
A[2] += min(target - row(0), target - col(2))
A[3] += min(target - row(1), target - col(0))
A[4] += min(target - row(1), target - col(1))
A[5] += min(target - row(1), target - col(2))
A[6] += min(target - row(2), target - col(0))
A[7] += min(target - row(2), target - col(1))
A[8] += min(target - row(2), target - col(2))
return A
Code: 20:02:59 UTC,
py,
autosave
# 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
def row(i):
return A[i * 3] + A[i * 3 + 1] + A[i * 3 + 2]
def col(i):
return A[i] + A[i + 3] + A[i + 6]
abc = A[0] + A[1] + A[2]
dwf = A[3] + A[4] + A[5]
ghi = A[6] + A[7] + A[8]
adg = A[0] + A[3] + A[6]
beh = A[1] + A[4] + A[7]
cfi = A[2] + A[5] + A[8]
total = sum(row(i) + col(i) for i in range(3))
target = int(total / 6) + 1 if total % 6 else total // 6
A[0] += min(target - row(0), target - col(0))
A[1] += min(target - row(0), target - col(1))
A[2] += min(target - row(0), target - col(2))
A[3] += min(target - row(1), target - col(0))
A[4] += min(target - row(1), target - col(1))
A[5] += min(target - row(1), target - col(2))
A[6] += min(target - row(2), target - col(0))
A[7] += min(target - row(2), target - col(1))
A[8] += min(target - row(2), target - col(2))
return A
Code: 20:03:06 UTC,
py,
verify,
result: Passed
# 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
def row(i):
return A[i * 3] + A[i * 3 + 1] + A[i * 3 + 2]
def col(i):
return A[i] + A[i + 3] + A[i + 6]
total = sum(row(i) + col(i) for i in range(3))
target = int(total / 6) + 1 if total % 6 else total // 6
A[0] += min(target - row(0), target - col(0))
A[1] += min(target - row(0), target - col(1))
A[2] += min(target - row(0), target - col(2))
A[3] += min(target - row(1), target - col(0))
A[4] += min(target - row(1), target - col(1))
A[5] += min(target - row(1), target - col(2))
A[6] += min(target - row(2), target - col(0))
A[7] += min(target - row(2), target - col(1))
A[8] += min(target - row(2), target - col(2))
return A
Analysis
Code: 20:03:37 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug messag
e")
def solution(A):
# write your code in Python 3.6
def row(i):
return A[i * 3] + A[i * 3 + 1] + A[i * 3 + 2]
def col(i):
return A[i] + A[i + 3] + A[i + 6]
total = sum(row(i) + col(i) for i in range(3))
target = int(total / 6) + 1 if total % 6 else total // 6
A[0] += min(target - row(0), target - col(0))
A[1] += min(target - row(0), target - col(1))
A[2] += min(target - row(0), target - col(2))
A[3] += min(target - row(1), target - col(0))
A[4] += min(target - row(1), target - col(1))
A[5] += min(target - row(1), target - col(2))
A[6] += min(target - row(2), target - col(0))
A[7] += min(target - row(2), target - col(1))
A[8] += min(target - row(2), target - col(2))
return A
Code: 20:03:47 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
def row(i):
return A[i * 3] + A[i * 3 + 1] + A[i * 3 + 2]
def col(i):
return A[i] + A[i + 3] + A[i + 6]
total = sum(row(i) + col(i) for i in range(3))
target = int(total / 6) + 1 if total % 6 else total // 6
A[0] += min(target - row(0), target - col(0))
A[1] += min(target - row(0), target - col(1))
A[2] += min(target - row(0), target - col(2))
A[3] += min(target - row(1), target - col(0))
A[4] += min(target - row(1), target - col(1))
A[5] += min(target - row(1), target - col(2))
A[6] += min(target - row(2), target - col(0))
A[7] += min(target - row(2), target - col(1))
A[8] += min(target - row(2), target - col(2))
return A
Code: 20:04:17 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
def row(i):
return A[i * 3] + A[i * 3 + 1] + A[i * 3 + 2]
def col(i):
return A[i] + A[i + 3] + A[i + 6]
total = sum(row(i) + col(i) for i in range(3))
# target the average of the rows (rounding up since we can't decrement)
# this should allow for the fewest number of changes
target = int(total / 6) + 1 if total % 6 else total // 6
A[0] += min(target - row(0), target - col(0))
A[1] += min(target - row(0), target - col(1))
A[2] += min(target - row(0), target - col(2))
A[3] += min(target - row(1), target - col(0))
A[4] += min(target - row(1), target - col(1))
A[5] += min(target - row(1), target - col(2))
A[6] += min(target - row(2), target - col(0))
A[7] += min(target - row(2), target - col(1))
A[8] += min(target - row(2), target - col(2))
return A
Code: 20:04:40 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
def row(i):
return A[i * 3] + A[i * 3 + 1] + A[i * 3 + 2]
def col(i):
return A[i] + A[i + 3] + A[i + 6]
# target the average of the rows (rounding up since we can't decrement)
# this should allow for the fewest number of increments
total = sum(row(i) + col(i) for i in range(3))
target = int(total / 6) + 1 if total % 6 else total // 6
# increment as much as needed based on row/col constraints
A[0] += min(target - row(0), target - col(0))
A[1] += min(target - row(0), target - col(1))
A[2] += min(target - row(0), target - col(2))
A[3] += min(target - row(1), target - col(0))
A[4] += min(target - row(1), target - col(1))
A[5] += min(target - row(1), target - col(2))
A[6] += min(target - row(2), target - col(0))
A[7] += min(target - row(2), target - col(1))
A[8] += min(target - row(2), target - col(2))
return A
Code: 20:04:49 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
def row(i):
return A[i * 3] + A[i * 3 + 1] + A[i * 3 + 2]
def col(i):
return A[i] + A[i + 3] + A[i + 6]
# target the average of the rows (rounding up since we can't decrement)
# this should allow for the fewest number of increments
total = sum(row(i) + col(i) for i in range(3))
target = int(total / 6) + 1 if total % 6 else total // 6
# increment as much as needed based on row/col constraints
A[0] += min(target - row(0), target - col(0))
A[1] += min(target - row(0), target - col(1))
A[2] += min(target - row(0), target - col(2))
A[3] += min(target - row(1), target - col(0))
A[4] += min(target - row(1), target - col(1))
A[5] += min(target - row(1), target - col(2))
A[6] += min(target - row(2), target - col(0))
A[7] += min(target - row(2), target - col(1))
A[8] += min(target - row(2), target - col(2))
return A
Analysis
Code: 20:05:55 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
def row(i):
return A[i * 3] + A[i * 3 + 1] + A[i * 3 + 2]
def col(i):
return A[i] + A[i + 3] + A[i + 6]
# target the average of the rows (rounding up since we can't decrement)
# this should allow for the fewest number of increments
total = sum(row(i) + col(i) for i in range(3))
target = int(total / 6) + 1 if total % 6 else total // 6
# increment as much as needed based on row/col constraints
A[0] += min(target - row(0), target - col(0))
A[1] += min(target - row(0), target - col(1))
A[2] += min(target - row(0), target - col(2))
A[3] += min(target - row(1), target - col(0))
A[4] += min(target - row(1), target - col(1))
A[5] += min(target - row(1), target - col(2))
A[6] += min(target - row(2), target - col(0))
A[7] += min(target - row(2), target - col(1))
A[8] += min(target - row(2), target - col(2))
return A
Code: 20:06:13 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
def row(i):
return A[i * 3] + A[i * 3 + 1] + A[i * 3 + 2]
def col(i):
return A[i] + A[i + 3] + A[i + 6]
# target the average of the rows (rounding up since we can't decrement)
# this should allow for the fewest number of increments
target = max([row(0), row(1), row(2), col(0), col(1), col(2)])
#total = sum(row(i) + col(i) for i in range(3))
#target = int(total / 6) + 1 if total % 6 else total // 6
# increment as much as needed based on row/col constraints
A[0] += min(target - row(0), target - col(0))
A[1] += min(target - row(0), target - col(1))
A[2] += min(target - row(0), target - col(2))
A[3] += min(target - row(1), target - col(0))
A[4] += min(target - row(1), target - col(1))
A[5] += min(target - row(1), target - col(2))
A[6] += min(target - row(2), target - col(0))
A[7] += min(target - row(2), target - col(1))
A[8] += min(target - row(2), target - col(2))
return A
Analysis
Code: 20:06:25 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
def row(i):
return A[i * 3] + A[i * 3 + 1] + A[i * 3 + 2]
def col(i):
return A[i] + A[i + 3] + A[i + 6]
# target the largest existing su
# this should allow for the fewest number of increments
target = max([row(0), row(1), row(2), col(0), col(1), col(2)])
#total = sum(row(i) + col(i) for i in range(3))
#target = int(total / 6) + 1 if total % 6 else total // 6
# increment as much as needed based on row/col constraints
A[0] += min(target - row(0), target - col(0))
A[1] += min(target - row(0), target - col(1))
A[2] += min(target - row(0), target - col(2))
A[3] += min(target - row(1), target - col(0))
A[4] += min(target - row(1), target - col(1))
A[5] += min(target - row(1), target - col(2))
A[6] += min(target - row(2), target - col(0))
A[7] += min(target - row(2), target - col(1))
A[8] += min(target - row(2), target - col(2))
return A
Code: 20:06:36 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
def row(i):
return A[i * 3] + A[i * 3 + 1] + A[i * 3 + 2]
def col(i):
return A[i] + A[i + 3] + A[i + 6]
# target the largest existing sum as the sum for each row
# this should allow for the fewest number of increments
target = max([row(0), row(1), row(2), col(0), col(1), col(2)])
#total = sum(row(i) + col(i) for i in range(3))
#target = int(total / 6) + 1 if total % 6 else total // 6
# increment as much as needed based on row/col constraints
A[0] += min(target - row(0), target - col(0))
A[1] += min(target - row(0), target - col(1))
A[2] += min(target - row(0), target - col(2))
A[3] += min(target - row(1), target - col(0))
A[4] += min(target - row(1), target - col(1))
A[5] += min(target - row(1), target - col(2))
A[6] += min(target - row(2), target - col(0))
A[7] += min(target - row(2), target - col(1))
A[8] += min(target - row(2), target - col(2))
return A
Code: 20:06:46 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
def row(i):
return A[i * 3] + A[i * 3 + 1] + A[i * 3 + 2]
def col(i):
return A[i] + A[i + 3] + A[i + 6]
# target the largest existing sum as the sum for each row
# this should allow for the fewest number of increments
target = max([row(0), row(1), row(2), col(0), col(1), col(2)])
# increment as much as needed based on row/col constraints
A[0] += min(target - row(0), target - col(0))
A[1] += min(target - row(0), target - col(1))
A[2] += min(target - row(0), target - col(2))
A[3] += min(target - row(1), target - col(0))
A[4] += min(target - row(1), target - col(1))
A[5] += min(target - row(1), target - col(2))
A[6] += min(target - row(2), target - col(0))
A[7] += min(target - row(2), target - col(1))
A[8] += min(target - row(2), target - col(2))
return A
Code: 20:07:07 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
def row(i):
return A[i * 3] + A[i * 3 + 1] + A[i * 3 + 2]
def col(i):
return A[i] + A[i + 3] + A[i + 6]
# target the largest existing sum as the sum for each row
# this should allow for the fewest number of increments
target = max([row(0), row(1), row(2), col(0), col(1), col(2)])
# increment as much as needed based on row/col constraints
A[0] += min(target - row(0), target - col(0))
A[1] += min(target - row(0), target - col(1))
A[2] += min(target - row(0), target - col(2))
A[3] += min(target - row(1), target - col(0))
A[4] += min(target - row(1), target - col(1))
A[5] += min(target - row(1), target - col(2))
A[6] += min(target - row(2), target - col(0))
A[7] += min(target - row(2), target - col(1))
A[8] += min(target - row(2), target - col(2))
return A
Analysis
expand all
User tests
1.
0.036 s
OK
function result: [9, 1, 1, 1, 9, 1, 1, 1, 9]
function result: [9, 1, 1, 1, 9, 1, 1, 1, 9]
1.
0.036 s
OK
function result: [9, 1, 1, 1, 9, 1, 1, 1, 9]
function result: [9, 1, 1, 1, 9, 1, 1, 1, 9]
User test case 1:
[1, 1, 1, 1, 1, 1, 1, 1, 9]
User test case 2:
[1, 1, 1, 1, 9, 1, 1, 1, 1]
Code: 20:07:27 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
def row(i):
return A[i * 3] + A[i * 3 + 1] + A[i * 3 + 2]
def col(i):
return A[i] + A[i + 3] + A[i + 6]
# target the largest existing sum as the sum for each row
# this should allow for the fewest number of increments
target = max([row(0), row(1), row(2), col(0), col(1), col(2)])
# increment as much as needed based on row/col constraints
A[0] += min(target - row(0), target - col(0))
A[1] += min(target - row(0), target - col(1))
A[2] += min(target - row(0), target - col(2))
A[3] += min(target - row(1), target - col(0))
A[4] += min(target - row(1), target - col(1))
A[5] += min(target - row(1), target - col(2))
A[6] += min(target - row(2), target - col(0))
A[7] += min(target - row(2), target - col(1))
A[8] += min(target - row(2), target - col(2))
return A
Code: 20:07:30 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
def row(i):
return A[i * 3] + A[i * 3 + 1] + A[i * 3 + 2]
def col(i):
return A[i] + A[i + 3] + A[i + 6]
# target the largest existing sum as the sum for each row
# this should allow for the fewest number of increments
target = max([row(0), row(1), row(2), col(0), col(1), col(2)])
# increment as much as needed based on row/col constraints
A[0] += min(target - row(0), target - col(0))
A[1] += min(target - row(0), target - col(1))
A[2] += min(target - row(0), target - col(2))
A[3] += min(target - row(1), target - col(0))
A[4] += min(target - row(1), target - col(1))
A[5] += min(target - row(1), target - col(2))
A[6] += min(target - row(2), target - col(0))
A[7] += min(target - row(2), target - col(1))
A[8] += min(target - row(2), target - col(2))
return A
Analysis
expand all
User tests
1.
0.036 s
OK
function result: [9, 1, 1, 1, 9, 1, 1, 1, 9]
function result: [9, 1, 1, 1, 9, 1, 1, 1, 9]
1.
0.036 s
OK
function result: [10, 1, 1, 1, 9, 2, 1, 2, 9]
function result: [10, 1, 1, 1, 9, 2, 1, 2, 9]
User test case 1:
[1, 1, 1, 1, 1, 1, 1, 1, 9]
User test case 2:
[1, 1, 1, 1, 9, 1, 1, 2, 1]
Code: 20:08:15 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
def row(i):
return A[i * 3] + A[i * 3 + 1] + A[i * 3 + 2]
def col(i):
return A[i] + A[i + 3] + A[i + 6]
# target the largest existing sum as the sum for each row
# this should allow for the fewest number of increments
target = max([row(0), row(1), row(2), col(0), col(1), col(2)])
# increment as much as needed based on row/col constraints
A[0] += min(target - row(0), target - col(0))
A[1] += min(target - row(0), target - col(1))
A[2] += min(target - row(0), target - col(2))
A[3] += min(target - row(1), target - col(0))
A[4] += min(target - row(1), target - col(1))
A[5] += min(target - row(1), target - col(2))
A[6] += min(target - row(2), target - col(0))
A[7] += min(target - row(2), target - col(1))
A[8] += min(target - row(2), target - col(2))
return A
Code: 20:08:18 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
def row(i):
return A[i * 3] + A[i * 3 + 1] + A[i * 3 + 2]
def col(i):
return A[i] + A[i + 3] + A[i + 6]
# target the largest existing sum as the sum for each row
# this should allow for the fewest number of increments
target = max([row(0), row(1), row(2), col(0), col(1), col(2)])
# increment as much as needed based on row/col constraints
A[0] += min(target - row(0), target - col(0))
A[1] += min(target - row(0), target - col(1))
A[2] += min(target - row(0), target - col(2))
A[3] += min(target - row(1), target - col(0))
A[4] += min(target - row(1), target - col(1))
A[5] += min(target - row(1), target - col(2))
A[6] += min(target - row(2), target - col(0))
A[7] += min(target - row(2), target - col(1))
A[8] += min(target - row(2), target - col(2))
return A
Analysis
expand all
User tests
1.
0.036 s
OK
function result: [9, 1, 1, 1, 9, 1, 1, 1, 9]
function result: [9, 1, 1, 1, 9, 1, 1, 1, 9]
1.
0.036 s
OK
function result: [10, 1, 1, 1, 9, 2, 1, 2, 9]
function result: [10, 1, 1, 1, 9, 2, 1, 2, 9]
User test case 1:
[9, 1, 1, 1, 1, 1, 1, 1, 8]
User test case 2:
[1, 1, 1, 1, 9, 1, 1, 2, 1]
Code: 20:08:41 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
def row(i):
return A[i * 3] + A[i * 3 + 1] + A[i * 3 + 2]
def col(i):
return A[i] + A[i + 3] + A[i + 6]
# target the largest existing sum as the sum for each row
# this should allow for the fewest number of increments
target = max([row(0), row(1), row(2), col(0), col(1), col(2)])
# increment as much as needed based on row/col constraints
A[0] += min(target - row(0), target - col(0))
A[1] += min(target - row(0), target - col(1))
A[2] += min(target - row(0), target - col(2))
A[3] += min(target - row(1), target - col(0))
A[4] += min(target - row(1), target - col(1))
A[5] += min(target - row(1), target - col(2))
A[6] += min(target - row(2), target - col(0))
A[7] += min(target - row(2), target - col(1))
A[8] += min(target - row(2), target - col(2))
return A
Code: 20:08:41 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
def row(i):
return A[i * 3] + A[i * 3 + 1] + A[i * 3 + 2]
def col(i):
return A[i] + A[i + 3] + A[i + 6]
# target the largest existing sum as the sum for each row
# this should allow for the fewest number of increments
target = max([row(0), row(1), row(2), col(0), col(1), col(2)])
# increment as much as needed based on row/col constraints
A[0] += min(target - row(0), target - col(0))
A[1] += min(target - row(0), target - col(1))
A[2] += min(target - row(0), target - col(2))
A[3] += min(target - row(1), target - col(0))
A[4] += min(target - row(1), target - col(1))
A[5] += min(target - row(1), target - col(2))
A[6] += min(target - row(2), target - col(0))
A[7] += min(target - row(2), target - col(1))
A[8] += min(target - row(2), target - col(2))
return A
Analysis
expand all
User tests
1.
0.040 s
OK
function result: [9, 1, 1, 1, 9, 1, 1, 1, 9]
function result: [9, 1, 1, 1, 9, 1, 1, 1, 9]
1.
0.040 s
OK
function result: [10, 1, 1, 1, 9, 2, 1, 2, 9]
function result: [10, 1, 1, 1, 9, 2, 1, 2, 9]
1.
0.036 s
OK
function result: [1, 1, 1, 1, 1, 1, 1, 1, 1]
function result: [1, 1, 1, 1, 1, 1, 1, 1, 1]
User test case 1:
[9, 1, 1, 1, 1, 1, 1, 1, 8]
User test case 2:
[1, 1, 1, 1, 9, 1, 1, 2, 1]
User test case 3:
[1, 1, 1, 1, 1, 1, 1, 1, 1]
Code: 20:08:46 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
def row(i):
return A[i * 3] + A[i * 3 + 1] + A[i * 3 + 2]
def col(i):
return A[i] + A[i + 3] + A[i + 6]
# target the largest existing sum as the sum for each row
# this should allow for the fewest number of increments
target = max([row(0), row(1), row(2), col(0), col(1), col(2)])
# increment as much as needed based on row/col constraints
A[0] += min(target - row(0), target - col(0))
A[1] += min(target - row(0), target - col(1))
A[2] += min(target - row(0), target - col(2))
A[3] += min(target - row(1), target - col(0))
A[4] += min(target - row(1), target - col(1))
A[5] += min(target - row(1), target - col(2))
A[6] += min(target - row(2), target - col(0))
A[7] += min(target - row(2), target - col(1))
A[8] += min(target - row(2), target - col(2))
return A
Analysis
expand all
User tests
1.
0.036 s
OK
function result: [9, 1, 1, 1, 9, 1, 1, 1, 9]
function result: [9, 1, 1, 1, 9, 1, 1, 1, 9]
1.
0.036 s
OK
function result: [10, 1, 1, 1, 9, 2, 1, 2, 9]
function result: [10, 1, 1, 1, 9, 2, 1, 2, 9]
1.
0.036 s
OK
function result: [1, 1, 1, 1, 1, 1, 1, 1, 1]
function result: [1, 1, 1, 1, 1, 1, 1, 1, 1]
User test case 1:
[9, 1, 1, 1, 1, 1, 1, 1, 8]
User test case 2:
[1, 1, 1, 1, 9, 1, 1, 2, 1]
User test case 3:
[1, 1, 1, 1, 1, 1, 1, 1, 1]
Code: 20:08:48 UTC,
py,
final,
score:
100
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
def row(i):
return A[i * 3] + A[i * 3 + 1] + A[i * 3 + 2]
def col(i):
return A[i] + A[i + 3] + A[i + 6]
# target the largest existing sum as the sum for each row
# this should allow for the fewest number of increments
target = max([row(0), row(1), row(2), col(0), col(1), col(2)])
# increment as much as needed based on row/col constraints
A[0] += min(target - row(0), target - col(0))
A[1] += min(target - row(0), target - col(1))
A[2] += min(target - row(0), target - col(2))
A[3] += min(target - row(1), target - col(0))
A[4] += min(target - row(1), target - col(1))
A[5] += min(target - row(1), target - col(2))
A[6] += min(target - row(2), target - col(0))
A[7] += min(target - row(2), target - col(1))
A[8] += min(target - row(2), target - col(2))
return AAnalysis summary
The solution obtained perfect score.
Analysis
Detected time complexity:
O(1)
expand all
Correctness tests
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
4.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
4.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
4.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.040 s
OK
4.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
4.
0.036 s
OK
expand all
Correctness/performance tests
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
4.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
4.
0.036 s
OK
5.
0.036 s
OK
expand all
Performance tests
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
4.
0.036 s
OK
5.
0.036 s
OK
6.
0.036 s
OK
7.
0.036 s
OK
8.
0.036 s
OK
random_medium_range_zeros
Random matrices with medium value range, max - min <= 2000, and two zeros.
Random matrices with medium value range, max - min <= 2000, and two zeros.
✔
OK
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
4.
0.036 s
OK
5.
0.036 s
OK
6.
0.036 s
OK
7.
0.036 s
OK
8.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
4.
0.036 s
OK
5.
0.036 s
OK
6.
0.036 s
OK
7.
0.036 s
OK
8.
0.036 s
OK