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 68 minutes
Notes
not defined yet
Code: 11:35:40 UTC,
java,
autosave
Code: 11:56:50 UTC,
py,
autosave
Code: 11:57:05 UTC,
py,
autosave
Code: 11:57:09 UTC,
py,
autosave
Code: 11:57:16 UTC,
py,
autosave
Code: 11:57:19 UTC,
py,
autosave
Code: 11:57:21 UTC,
py,
autosave
Code: 11:57:32 UTC,
py,
autosave
Code: 11:57:35 UTC,
py,
autosave
Code: 11:57:35 UTC,
py,
autosave
Code: 11:57:53 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
#Step 1 find max sum
s = max([A[0] + A[1] + A[2],
A[3] + A[4] + A[5],
A[6] + A[7] + A[8],
A[0] + A[3] + A[6],
A[0] + A[3] + A[6],
A[0] + A[3] + A[6],
]
)
pass
Code: 11:58:08 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
#Step 1 find max sum
s = max([A[0] + A[1] + A[2],
A[3] + A[4] + A[5],
A[6] + A[7] + A[8],
A[0] + A[3] + A[6],
A[1] + A[4] + A[7],
A[2] + A[5] + A[8]]
)
pass
Code: 11:58:10 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
#Step 1 find max sum
s = max([A[0] + A[1] + A[2],
A[3] + A[4] + A[5],
A[6] + A[7] + A[8],
A[0] + A[3] + A[6],
A[1] + A[4] + A[7],
A[2] + A[5] + A[8]])
pass
Code: 11:58:13 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
#Step 1 find max sum
s = max([A[0] + A[1] + A[2],
A[3] + A[4] + A[5],
A[6] + A[7] + A[8],
A[0] + A[3] + A[6],
A[1] + A[4] + A[7],
A[2] + A[5] + A[8]])
print(s)
pass
Code: 11:58:15 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
#Step 1 find max sum
s = max([A[0] + A[1] + A[2],
A[3] + A[4] + A[5],
A[6] + A[7] + A[8],
A[0] + A[3] + A[6],
A[1] + A[4] + A[7],
A[2] + A[5] + A[8]])
print(s)
pass
Analysis
expand all
Example tests
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
6
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
5
Code: 11:58:32 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
#Step 1 find max sum
s = max([A[0] + A[1] + A[2],
A[3] + A[4] + A[5],
A[6] + A[7] + A[8],
A[0] + A[3] + A[6],
A[1] + A[4] + A[7],
A[2] + A[5] + A[8]])
print(s)
re
Code: 11:58:35 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
#Step 1 find max sum
s = max([A[0] + A[1] + A[2],
A[3] + A[4] + A[5],
A[6] + A[7] + A[8],
A[0] + A[3] + A[6],
A[1] + A[4] + A[7],
A[2] + A[5] + A[8]])
print(s)
return A;
Code: 11:58:37 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
#Step 1 find max sum
s = max([A[0] + A[1] + A[2],
A[3] + A[4] + A[5],
A[6] + A[7] + A[8],
A[0] + A[3] + A[6],
A[1] + A[4] + A[7],
A[2] + A[5] + A[8]])
print(s)
return A;
Code: 11:58:38 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
#Step 1 find max sum
s = max([A[0] + A[1] + A[2],
A[3] + A[4] + A[5],
A[6] + A[7] + A[8],
A[0] + A[3] + A[6],
A[1] + A[4] + A[7],
A[2] + A[5] + A[8]])
print(s)
return A;
Analysis
expand all
Example tests
1.
0.036 s
WRONG ANSWER,
Not all rows and columns have the same sum.
stdout:
6
1.
0.036 s
WRONG ANSWER,
Not all rows and columns have the same sum.
stdout:
5
Code: 11:58:51 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
#Step 1 find max sum
s = max([A[0] + A[1] + A[2],
A[3] + A[4] + A[5],
A[6] + A[7] + A[8],
A[0] + A[3] + A[6],
A[1] + A[4] + A[7],
A[2] + A[5] + A[8]])
print("maximal sum", s)
return A;
Analysis
expand all
Example tests
1.
0.036 s
WRONG ANSWER,
Not all rows and columns have the same sum.
stdout:
maximal sum 6
1.
0.036 s
WRONG ANSWER,
Not all rows and columns have the same sum.
stdout:
maximal sum 5
Code: 11:58: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
#Step 1 find max sum
s = max([A[0] + A[1] + A[2],
A[3] + A[4] + A[5],
A[6] + A[7] + A[8],
A[0] + A[3] + A[6],
A[1] + A[4] + A[7],
A[2] + A[5] + A[8]])
print("maximal sum", s)
return A;
Code: 11:59:03 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
#Step 1 find max sum
s = max([A[0] + A[1] + A[2],
A[3] + A[4] + A[5],
A[6] + A[7] + A[8],
A[0] + A[3] + A[6],
A[1] + A[4] + A[7],
A[2] + A[5] + A[8]])
print("maximal sum", s)
#Step 2
r
return A;
Code: 11:59:13 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
#Step 1 find max sum
s = max([A[0] + A[1] + A[2],
A[3] + A[4] + A[5],
A[6] + A[7] + A[8],
A[0] + A[3] + A[6],
A[1] + A[4] + A[7],
A[2] + A[5] + A[8]])
print("maximal sum", s)
#Step 2
rows = {}
cols = {}
return A;
Code: 11:59: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
#Step 1 find max sum
s = max([A[0] + A[1] + A[2],
A[3] + A[4] + A[5],
A[6] + A[7] + A[8],
A[0] + A[3] + A[6],
A[1] + A[4] + A[7],
A[2] + A[5] + A[8]])
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = {}
cols = {}
return A;
Code: 11:59:33 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
#Step 1 find max sum
s = max([A[0] + A[1] + A[2],
A[3] + A[4] + A[5],
A[6] + A[7] + A[8],
A[0] + A[3] + A[6],
A[1] + A[4] + A[7],
A[2] + A[5] + A[8]])
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = {}
cols = {}
return A;
Code: 11:59: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
#Step 1 find max sum
row_sums = []
r
s = max([A[0] + A[1] + A[2],
A[3] + A[4] + A[5],
A[6] + A[7] + A[8],
A[0] + A[3] + A[6],
A[1] + A[4] + A[7],
A[2] + A[5] + A[8]])
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = {}
cols = {}
return A;
Code: 12:00:03 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
s = max([A[0] + A[1] + A[2],
A[3] + A[4] + A[5],
A[6] + A[7] + A[8],
A[0] + A[3] + A[6],
A[1] + A[4] + A[7],
A[2] + A[5] + A[8]])
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = {}
cols = {}
return A;
Code: 12:00:14 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[1] + A[2])
row_sums.append(A[6] + A[1] + A[2])
s = max([A[0] + A[1] + A[2],
A[3] + A[4] + A[5],
A[6] + A[7] + A[8],
A[0] + A[3] + A[6],
A[1] + A[4] + A[7],
A[2] + A[5] + A[8]])
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = {}
cols = {}
return A;
Code: 12:00:24 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
s = max([A[0] + A[1] + A[2],
A[3] + A[4] + A[5],
A[6] + A[7] + A[8],
A[0] + A[3] + A[6],
A[1] + A[4] + A[7],
A[2] + A[5] + A[8]])
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = {}
cols = {}
return A;
Code: 12:00:32 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append()
s = max([A[0] + A[1] + A[2],
A[3] + A[4] + A[5],
A[6] + A[7] + A[8],
A[0] + A[3] + A[6],
A[1] + A[4] + A[7],
A[2] + A[5] + A[8]])
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = {}
cols = {}
return A;
Code: 12:00: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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max([A[0] + A[1] + A[2],
A[3] + A[4] + A[5],
A[6] + A[7] + A[8],
A[0] + A[3] + A[6],
A[1] + A[4] + A[7],
A[2] + A[5] + A[8]])
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = {}
cols = {}
return A;
Code: 12:01:04 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(row_sums)
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = {}
cols = {}
return A;
Code: 12:01:17 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = {}
cols = {}
return A;
Code: 12:01:34 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = {}
cols = {}
for i range(3):
if (row_sums[i] == a)
return A;
Code: 12:01:45 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = {}
cols = {}
for i range(3):
if (row_sums[i] != s):
rows.
return A;
Code: 12:02:16 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = {}
cols = {}
for i range(3):
if (row_sums[i] != s):
rows.add(i)
return A;
Code: 12:02:31 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = {}
cols = {}
for i range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
rows.add(i)
return A;
Code: 12:02:37 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = {}
cols = {}
for i range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
return A;
Code: 12:02:41 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = {}
cols = {}
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
return A;
Code: 12:02:47 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = {}
cols = {}
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
print(rows)
print(cols)
return A;
Code: 12:02:49 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = {}
cols = {}
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
print(rows)
print(cols)
return A;
Analysis
expand all
Example tests
1.
0.056 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 28, in solution
rows.add(i)
AttributeError: 'dict' object has no attribute 'add'
stdout:
maximal sum 6
1.
0.056 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 28, in solution
rows.add(i)
AttributeError: 'dict' object has no attribute 'add'
stdout:
maximal sum 5
Code: 12:03:01 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = s
cols = {}
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
print(rows)
print(cols)
return A;
Code: 12:03:05 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
print(rows)
print(cols)
return A;
Code: 12:03:08 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
print(rows)
print(cols)
return A;
Analysis
expand all
Example tests
1.
0.036 s
WRONG ANSWER,
Not all rows and columns have the same sum.
stdout:
maximal sum 6
{0, 2}
{0, 2}
1.
0.036 s
WRONG ANSWER,
Not all rows and columns have the same sum.
stdout:
maximal sum 5
{0}
{2}
Code: 12:03: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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
print(rows)
print(cols)
return A;
Code: 12:04:00 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
print(rows)
print(cols)
while(len(rows) > 0):
return A;
Code: 12:04:10 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
print(rows)
print(cols)
while(len(rows) > 0):
return A;
Code: 12:04:40 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
print(rows)
print(cols)
while(len(rows) > 0):
return A;
Code: 12:04: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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
print(rows)
print(cols)
while(len(rows) > 0):
return A;
Code: 12:05:22 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
print(rows)
print(cols)
while(len(rows) > 0):
a
return A;
Code: 12:05:37 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
print(rows)
print(cols)
while(len(rows) > 0):
rid = rows.pop()
return A;
Code: 12:05: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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
print(rows)
print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
return A;
Code: 12:05:52 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
print(rows)
print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = row_sums
return A;
Code: 12:05: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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
print(rows)
print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = row_sums[r_id]
return A;
Code: 12:06:22 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
print(rows)
print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - (max(row_sums[r_id], co
return A;
Code: 12:06:31 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
print(rows)
print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - (max(row_sums[r_id], col_sums[c_id]))
return A;
Code: 12:06: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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
print(rows)
print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - (max(row_sums[r_id], col_sums[c_id]))
return A;
Code: 12:06:43 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
print(rows)
print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[r_id], col_sums[c_id])
return A;
Code: 12:06:56 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
print(rows)
print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
return A;
Code: 12:07:08 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
print(rows)
print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[]
return A;
Code: 12:07: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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
print(rows)
print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid
return A;
Code: 12:07:43 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
print(rows)
print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
i
return A;
Code: 12:07:57 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
print(rows)
print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] == s)
return A;
Code: 12:08:27 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
print(rows)
print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
return A;
Code: 12:08:30 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
print(rows)
print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
return A;
Code: 12:08: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):
# write your code in Python 3.6
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
print(rows)
print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
return A;
Analysis
expand all
Example tests
1.
0.036 s
OK
stdout:
maximal sum 6
{0, 2}
{0, 2}
1.
0.036 s
OK
stdout:
maximal sum 5
{0}
{2}
Code: 12:08:57 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
return A;
Code: 12:09:00 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
return A;
Code: 12:09:08 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
return A;
Analysis
Code: 12:09:53 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
return A;
Code: 12:09:58 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
Code: 12:10:00 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
Analysis
expand all
Example tests
1.
0.036 s
OK
stdout:
[1, 2, 3, 4, 1, 1, 1, 3, 2]
1.
0.040 s
OK
stdout:
[1, 1, 3, 2, 2, 1, 2, 2, 1]
Code: 12:10:41 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
Code: 12:10:52 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455
# 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
if __name__ == "__main__":
print("main")
Code: 12:10:53 UTC,
py,
verify,
result: Passed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455
# 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
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
if __name__ == "__main__":
print("main")
Analysis
expand all
Example tests
1.
0.036 s
OK
stdout:
[1, 2, 3, 4, 1, 1, 1, 3, 2]
1.
0.036 s
OK
stdout:
[1, 1, 3, 2, 2, 1, 2, 2, 1]
Code: 12:11:11 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solve_core(A)
def solution(A):
# write your code in Python 3.6
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
if __name__ == "__main__":
print("main")
Code: 12:11:27 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def solution(A):
if __name__ == "__main__":
print("main")
Code: 12:11:53 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def exp():
for i in range(100):
n = rand()
def solution(A):
if __name__ == "__main__":
print("main")
Code: 12:12:06 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import rand
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def exp():
for i in range(100):
n = rand()
def solution(A):
if __name__ == "__main__":
print("main")
Code: 12:12:10 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def exp():
for i in range(100):
n = rand()
def solution(A):
if __name__ == "__main__":
print("main")
Code: 12:12:23 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def exp():
for i in range(100):
n = randint(1, 9)
def solution(A):
if __name__ == "__main__":
print("main")
Code: 12:12:33 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def exp():
A = []
for i in range(100):
a.
def solution(A):
if __name__ == "__main__":
print("main")
Code: 12:12:49 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def exp():
A = 9 * [0]
for i in range(100):
a[i]
def solution(A):
if __name__ == "__main__":
print("main")
Code: 12:13:16 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def exp():
A = 9 * [0]
for i in range(100):
A = []
for j in range(9):
A.push_back(randint(0,100000000))
a[i]
def solution(A):
if __name__ == "__main__":
print("main")
Code: 12:13:23 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def exp():
A = 9 * [0]
for i in range(100):
A = []
for j in range(9):
A.push_back(randint(0,100000000))
def solution(A):
if __name__ == "__main__":
print("main")
Code: 12:13:46 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def exp():
A = 9 * [0]
for i in range(100):
A = []
for j in range(9):
A.push_back(randint(0,100000000))
A = solve_core(A)
reevaluate(A)
def solution(A):
if __name__ == "__main__":
print("main")
Code: 12:14:05 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def exp():
A = 9 * [0]
for i in range(100):
A = []
for j in range(9):
A.push_back(randint(0,100000000))
A = solve_core(A)
res = evaluate(A)
assert(res)
def solution(A):
exp()
solve_core(A)
if __name__ == "__main__":
print("main")
Code: 12:14:09 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def exp():
A = 9 * [0]
for i in range(100):
A = []
for j in range(9):
A.push_back(randint(0,100000000))
A = solve_core(A)
res = evaluate(A)
assert(res)
def solution(A):
exp()
solve_core(A)
Code: 12:14:20 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def evaluate(A):
def exp():
A = 9 * [0]
for i in range(100):
A = []
for j in range(9):
A.push_back(randint(0,100000000))
A = solve_core(A)
res = evaluate(A)
assert(res)
def solution(A):
exp()
solve_core(A)
Code: 12:14:35 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def evaluate(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
def exp():
A = 9 * [0]
for i in range(100):
A = []
for j in range(9):
A.push_back(randint(0,100000000))
A = solve_core(A)
res = evaluate(A)
assert(res)
def solution(A):
exp()
solve_core(A)
Code: 12:14:57 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s =
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
def exp():
A = 9 * [0]
for i in range(100):
A = []
for j in range(9):
A.push_back(randint(0,100000000))
A = solve_core(A)
res = evaluate(A)
assert(res)
def solution(A):
exp()
solve_core(A)
Code: 12:15:27 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
if (A[3*i] + A[3*i + 1] + A[3*i + 2])
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
def exp():
A = 9 * [0]
for i in range(100):
A = []
for j in range(9):
A.push_back(randint(0,100000000))
A = solve_core(A)
res = evaluate(A)
assert(res)
def solution(A):
exp()
solve_core(A)
Code: 12:15:48 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s)
return False
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s)
return False
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
def exp():
A = 9 * [0]
for i in range(100):
A = []
for j in range(9):
A.push_back(randint(0,100000000))
A = solve_core(A)
res = evaluate(A)
assert(res)
def solution(A):
exp()
solve_core(A)
Code: 12:16:26 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s)
return False
#rows
if (A[1] + A[3*i + 1] + A[3*i + 2] != s)
return False
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
def exp():
A = 9 * [0]
for i in range(100):
A = []
for j in range(9):
A.push_back(randint(0,100000000))
A = solve_core(A)
res = evaluate(A)
assert(res)
def solution(A):
exp()
solve_core(A)
Code: 12:16:36 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s)
return False
#rows
if (A[] + A[3*i + 1] + A[3*i + 2] != s)
return False
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
def exp():
A = 9 * [0]
for i in range(100):
A = []
for j in range(9):
A.push_back(randint(0,100000000))
A = solve_core(A)
res = evaluate(A)
assert(res)
def solution(A):
exp()
solve_core(A)
Code: 12:16:59 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s)
return False
#rows
if (A[i] + A[3*i + 1] + A[3*i + 2] != s)
return False
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
def exp():
A = 9 * [0]
for i in range(100):
A = []
for j in range(9):
A.push_back(randint(0,100000000))
A = solve_core(A)
res = evaluate(A)
assert(res)
def solution(A):
exp()
solve_core(A)
Code: 12:17:16 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s)
return False
#rows
if (A[i] + A[i + 3] + A[i + 6] != s)
return False
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
def exp():
A = 9 * [0]
for i in range(100):
A = []
for j in range(9):
A.push_back(randint(0,100000000))
A = solve_core(A)
res = evaluate(A)
assert(res)
def solution(A):
exp()
solve_core(A)
Code: 12:17:40 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s)
return False
return True
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
def exp():
A = 9 * [0]
for i in range(100):
A = []
for j in range(9):
A.push_back(randint(0,100000000))
A = solve_core(A)
res = evaluate(A)
assert(res)
def solution(A):
exp()
solve_core(A)
Code: 12:17:47 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s)
return False
return True
def exp():
A = 9 * [0]
for i in range(100):
A = []
for j in range(9):
A.push_back(randint(0,100000000))
A = solve_core(A)
res = evaluate(A)
assert(res)
def solution(A):
exp()
solve_core(A)
Code: 12:17:59 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s)
return False
return True
def exp():
A = 9 * [0]
for i in range(100):
A = []
for j in range(9):
A.push_back(randint(0,100000000))
A = solve_core(A)
res = evaluate(A)
assert(res)
def solution(A):
exp()
solve_core(A)
Code: 12:18:10 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(100):
A = []
for j in range(9):
A.push_back(randint(0,100000000))
A = solve_core(A)
res = evaluate(A)
assert(res)
def solution(A):
exp()
solve_core(A)
Code: 12:18:10 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(100):
A = []
for j in range(9):
A.push_back(randint(0,100000000))
A = solve_core(A)
res = evaluate(A)
assert(res)
def solution(A):
exp()
solve_core(A)
Code: 12:18:40 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(100):
A = []
for j in range(9):
A.push_back(randint(0,100000000))
A = solve_core(A)
assert(evaluate(A))
def solution(A):
exp()
solve_core(A)
Code: 12:18:43 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(10):
A = []
for j in range(9):
A.push_back(randint(0,100000000))
A = solve_core(A)
assert(evaluate(A))
def solution(A):
exp()
solve_core(A)
Code: 12:18:48 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(10):
A = []
for j in range(9):
A.push_back(randint(0, 100))
A = solve_core(A)
assert(evaluate(A))
def solution(A):
exp()
solve_core(A)
Code: 12:18:49 UTC,
py,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(10):
A = []
for j in range(9):
A.push_back(randint(0, 100))
A = solve_core(A)
assert(evaluate(A))
def solution(A):
exp()
solve_core(A)
Analysis
expand all
Example tests
1.
0.040 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 141, in <module>
main()
File "exec.py", line 103, in main
result = solution( A )
File "/tmp/solution.py", line 82, in solution
exp()
File "/tmp/solution.py", line 75, in exp
A.push_back(randint(0, 100))
AttributeError: 'list' object has no attribute 'push_back'
1.
0.040 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 82, in solution
exp()
File "/tmp/solution.py", line 75, in exp
A.push_back(randint(0, 100))
AttributeError: 'list' object has no attribute 'push_back'
Code: 12:18:58 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(10):
A = []
for j in range(9):
A.append(randint(0, 100))
A = solve_core(A)
assert(evaluate(A))
def solution(A):
exp()
solve_core(A)
Code: 12:18:59 UTC,
py,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(10):
A = []
for j in range(9):
A.append(randint(0, 100))
A = solve_core(A)
assert(evaluate(A))
def solution(A):
exp()
solve_core(A)
Analysis
expand all
Example tests
1.
0.040 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
[81, 119, 3, 94, 35, 74, 28, 49, 126] [13, 86, 94, 107, 11, 75, 73, 96, 24] [52, 42, 93, 64, 120, 3, 71, 25, 91] [83, 89, 69, 83, 28, 130, 75, 124, 42] [112, 20, 89, 54, 132, 35, 55, 69, 97] [62, 16, 76, 48, 61, 45, 44, 77, 33] [27, 93, 58, 80, 15, 83, 71, 70, 37] [95, 79, 46, 73, 57, 90, 52, 84, 84] [29, 98, 37, 87, 29, 48, 48, 37, 79] [81, 112, 20, 47, 62, 104, 85, 39, 89] [1, 2, 3, 4, 1, 1, 1, 3, 2]
1.
0.040 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
[81, 119, 3, 94, 35, 74, 28, 49, 126] [13, 86, 94, 107, 11, 75, 73, 96, 24] [52, 42, 93, 64, 120, 3, 71, 25, 91] [83, 89, 69, 83, 28, 130, 75, 124, 42] [112, 20, 89, 54, 132, 35, 55, 69, 97] [62, 16, 76, 48, 61, 45, 44, 77, 33] [27, 93, 58, 80, 15, 83, 71, 70, 37] [95, 79, 46, 73, 57, 90, 52, 84, 84] [29, 98, 37, 87, 29, 48, 48, 37, 79] [81, 112, 20, 47, 62, 104, 85, 39, 89] [1, 1, 3, 2, 2, 1, 2, 2, 1]
Code: 12:19:19 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(10):
A = []
for j in range(9):
A.append(randint(0, 100))
A = solve_core(A)
assert(evaluate(A))
def solution(A):
exp()
solve_core(A)
Code: 12:19:24 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(10):
A = []
for j in range(9):
A.append(randint(0, 100))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
solve_core(A)
Code: 12:19:24 UTC,
py,
verify,
result: Failed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(10):
A = []
for j in range(9):
A.append(randint(0, 100))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
solve_core(A)
Analysis
expand all
Example tests
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
[81, 119, 3, 94, 35, 74, 28, 49, 126] [13, 86, 94, 107, 11, 75, 73, 96, 24] [52, 42, 93, 64, 120, 3, 71, 25, 91] [83, 89, 69, 83, 28, 130, 75, 124, 42] [112, 20, 89, 54, 132, 35, 55, 69, 97] [62, 16, 76, 48, 61, 45, 44, 77, 33] [27, 93, 58, 80, 15, 83, 71, 70, 37] [95, 79, 46, 73, 57, 90, 52, 84, 84] [29, 98, 37, 87, 29, 48, 48, 37, 79] [81, 112, 20, 47, 62, 104, 85, 39, 89] ALL GOOD [1, 2, 3, 4, 1, 1, 1, 3, 2]
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
[81, 119, 3, 94, 35, 74, 28, 49, 126] [13, 86, 94, 107, 11, 75, 73, 96, 24] [52, 42, 93, 64, 120, 3, 71, 25, 91] [83, 89, 69, 83, 28, 130, 75, 124, 42] [112, 20, 89, 54, 132, 35, 55, 69, 97] [62, 16, 76, 48, 61, 45, 44, 77, 33] [27, 93, 58, 80, 15, 83, 71, 70, 37] [95, 79, 46, 73, 57, 90, 52, 84, 84] [29, 98, 37, 87, 29, 48, 48, 37, 79] [81, 112, 20, 47, 62, 104, 85, 39, 89] ALL GOOD [1, 1, 3, 2, 2, 1, 2, 2, 1]
Code: 12:19:33 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(10):
A = []
for j in range(9):
A.append(randint(0, 100000000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
solve_core(A)
Code: 12:19:33 UTC,
py,
verify,
result: Failed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(10):
A = []
for j in range(9):
A.append(randint(0, 100000000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
solve_core(A)
Analysis
expand all
Example tests
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
[85822412, 126131175, 3356886, 99529223, 36913810, 78867440, 29958838, 52265488, 133086147] [13756669, 90825067, 99410741, 113069182, 11668732, 79254563, 77166626, 101498678, 25327173] [54962424, 44701698, 98454977, 67827638, 126729864, 3561597, 75329037, 26687537, 96102525] [87226012, 94130244, 73140807, 88181150, 29587039, 136728874, 79089901, 130779780, 44627382] [25749871, 93702683, 56722344, 45667651, 37295260, 93211987, 104757376, 45176955, 26240567] [108269945, 70703733, 12981052, 48181396, 62742598, 81030736, 35503389, 58508399, 97942942] [116584896, 71971316, 18184430, 50806024, 50394721, 105539897, 39349722, 84374605, 83016315] [48537831, 157510754, 25808537, 94566031, 9335534, 127955557, 88753260, 65010834, 78093028] [19778331, 62908432, 73431367, 51019678, 44242752, 60855700, 85320121, 48966946, 21831063] [49684848, 108567458, 73126145, 89949389, 35833156, 105595906, 91744214, 86977837, 52656400] ALL GOOD [1, 2, 3, 4, 1, 1, 1, 3, 2]
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
[85822412, 126131175, 3356886, 99529223, 36913810, 78867440, 29958838, 52265488, 133086147] [13756669, 90825067, 99410741, 113069182, 11668732, 79254563, 77166626, 101498678, 25327173] [54962424, 44701698, 98454977, 67827638, 126729864, 3561597, 75329037, 26687537, 96102525] [87226012, 94130244, 73140807, 88181150, 29587039, 136728874, 79089901, 130779780, 44627382] [25749871, 93702683, 56722344, 45667651, 37295260, 93211987, 104757376, 45176955, 26240567] [108269945, 70703733, 12981052, 48181396, 62742598, 81030736, 35503389, 58508399, 97942942] [116584896, 71971316, 18184430, 50806024, 50394721, 105539897, 39349722, 84374605, 83016315] [48537831, 157510754, 25808537, 94566031, 9335534, 127955557, 88753260, 65010834, 78093028] [19778331, 62908432, 73431367, 51019678, 44242752, 60855700, 85320121, 48966946, 21831063] [49684848, 108567458, 73126145, 89949389, 35833156, 105595906, 91744214, 86977837, 52656400] ALL GOOD [1, 1, 3, 2, 2, 1, 2, 2, 1]
Code: 12:19:52 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(10):
A = []
for j in range(9):
A.append(randint(0, 1000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
solve_core(A)
Code: 12:19:55 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1000):
A = []
for j in range(9):
A.append(randint(0, 1000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
solve_core(A)
Code: 12:19:56 UTC,
py,
verify,
result: Failed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1000):
A = []
for j in range(9):
A.append(randint(0, 1000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
solve_core(A)
Analysis
expand all
Example tests
1.
0.072 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
[654, 962, 25, 759, 281, 601, 228, 398, 1015] [165, 692, 825, 913, 558, 211, 604, 432, 646] [1053, 95, 223, 238, 517, 616, 80, 759, 532] [733, 665, 718, 924, 429, 763, 459, 1022, 635] [828, 1062, 429, 777, 825, 717, 714, 432, 1173] [1021, 159, 925, 980, 781, 344, 104, 1165, 836] [650, 367, 867, 352, 1262, 270, 882, 255, 747] [1251, 549, 527, 996, 944, 387, 80, 834, 1413] [849, 864, 633, 906, 882, 558, 591, 600, 1155] [989, 46, 677, 233, 791, 688, 490, 875, 347] [887, 749, 389, 284, 464, 1277, 854, 812, 359] [676, 705, 940, 686, 917, 718, 959, 699, 663] [596, 623, 650, 175, 948, 746, 1098, 298, 473] [706, 276, 947, 655, 704, 570, 568, 949, 412] [863, 786, 794, 1368, 234, 841, 212, 1423, 808] [1416, 284, 512, 216, 1031, 965, 580, 897, 735] [616, 758, 689, 511, 647, 905, 936, 658, 469] [785, 553, 250, 252, 762, 574, 551, 273, 764] [598, 438, 919, 1133, 408, 414, 224, 1109, 622] [750, 93, 773, 55, 881, 680, 811, 642, 163] [811, 696, 432, 738, 173, 1028, 390, 1070, 479] [1446, 257, 994, 566, 1166, 965, 685, 1274, 738] [518, 698, 906, 549, 768, 805, 1055, 656, 411] [1474, 300, 837, 161, 1572, 878, 976, 739, 896] [736, 269, 995, 745, 780, 475, 519, 951, 530] [891, 1179, 305, 861, 654, 860, 623, 542, 1210] [931, 806, 690, 552, 1078, 797, 944, 543, 940] [770, 613, 838, 500, 1237, 484, 951, 371, 899] [1304, 826, 318, 245, 1042, 1161, 899, 580, 969] [832, 87, 1188, 497, 1475, 135, 778, 545, 784] [1211, 131, 675, 486, 969, 562, 320, 917, 780] [893, 1106, 433, 987, 216, 1229, 552, 1110, 770] [881, 254, 730, 319, 859, 687, 665, 752, 448] [921, 529, 462, 926, 253, 733, 65, 1130, 717] [714, 567, 235, 656, 225, 635, 146, 724, 646] [574, 832, 433, 927, 32, 880, 338, 975, 526] [1224, 285, 685, 497, 1145, 552, 473, 764, 957] [903, 584, 590, 690, 316, 1071, 484, 1177, 416] [370, 470, 637, 674, 441, 362, 433, 566, 478] [1218, 746, 55, 689, 669, 661, 112, 604, 1303] [745, 347, 819, 970, 398, 543, 196, 1166, 549] [1520, 143, 432, 320, 1057, 718, 255, 895, 945] [1041, 453, 827, 882, 876, 563, 398, 992, 931] [553, 1352, 411, 992, 95, 1229
1.
0.072 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
[654, 962, 25, 759, 281, 601, 228, 398, 1015] [165, 692, 825, 913, 558, 211, 604, 432, 646] [1053, 95, 223, 238, 517, 616, 80, 759, 532] [733, 665, 718, 924, 429, 763, 459, 1022, 635] [828, 1062, 429, 777, 825, 717, 714, 432, 1173] [1021, 159, 925, 980, 781, 344, 104, 1165, 836] [650, 367, 867, 352, 1262, 270, 882, 255, 747] [1251, 549, 527, 996, 944, 387, 80, 834, 1413] [849, 864, 633, 906, 882, 558, 591, 600, 1155] [989, 46, 677, 233, 791, 688, 490, 875, 347] [887, 749, 389, 284, 464, 1277, 854, 812, 359] [676, 705, 940, 686, 917, 718, 959, 699, 663] [596, 623, 650, 175, 948, 746, 1098, 298, 473] [706, 276, 947, 655, 704, 570, 568, 949, 412] [863, 786, 794, 1368, 234, 841, 212, 1423, 808] [1416, 284, 512, 216, 1031, 965, 580, 897, 735] [616, 758, 689, 511, 647, 905, 936, 658, 469] [785, 553, 250, 252, 762, 574, 551, 273, 764] [598, 438, 919, 1133, 408, 414, 224, 1109, 622] [750, 93, 773, 55, 881, 680, 811, 642, 163] [811, 696, 432, 738, 173, 1028, 390, 1070, 479] [1446, 257, 994, 566, 1166, 965, 685, 1274, 738] [518, 698, 906, 549, 768, 805, 1055, 656, 411] [1474, 300, 837, 161, 1572, 878, 976, 739, 896] [736, 269, 995, 745, 780, 475, 519, 951, 530] [891, 1179, 305, 861, 654, 860, 623, 542, 1210] [931, 806, 690, 552, 1078, 797, 944, 543, 940] [770, 613, 838, 500, 1237, 484, 951, 371, 899] [1304, 826, 318, 245, 1042, 1161, 899, 580, 969] [832, 87, 1188, 497, 1475, 135, 778, 545, 784] [1211, 131, 675, 486, 969, 562, 320, 917, 780] [893, 1106, 433, 987, 216, 1229, 552, 1110, 770] [881, 254, 730, 319, 859, 687, 665, 752, 448] [921, 529, 462, 926, 253, 733, 65, 1130, 717] [714, 567, 235, 656, 225, 635, 146, 724, 646] [574, 832, 433, 927, 32, 880, 338, 975, 526] [1224, 285, 685, 497, 1145, 552, 473, 764, 957] [903, 584, 590, 690, 316, 1071, 484, 1177, 416] [370, 470, 637, 674, 441, 362, 433, 566, 478] [1218, 746, 55, 689, 669, 661, 112, 604, 1303] [745, 347, 819, 970, 398, 543, 196, 1166, 549] [1520, 143, 432, 320, 1057, 718, 255, 895, 945] [1041, 453, 827, 882, 876, 563, 398, 992, 931] [553, 1352, 411, 992, 95, 1229
Code: 12:20:14 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1000):
A = []
for j in range(9):
A.append(randint(0, 1000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
solve_core(A)
Code: 12:20:15 UTC,
py,
verify,
result: Failed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1000):
A = []
for j in range(9):
A.append(randint(0, 1000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
solve_core(A)
Analysis
expand all
Example tests
1.
0.068 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
ALL GOOD
1.
0.068 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
ALL GOOD
Code: 12:21:53 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
solve_core(A)
Code: 12:22:03 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
solve_core(A)
Code: 12:22:12 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1;
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
solve_core(A)
Code: 12:22:21 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
solve_core(A)
Code: 12:22:22 UTC,
py,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
solve_core(A)
Analysis
expand all
Example tests
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
Total Moves 4 ALL GOOD Total Moves 2
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
Total Moves 4 ALL GOOD Total Moves 1
Code: 12:22:54 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:22:56 UTC,
py,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Analysis
expand all
Example tests
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
Total Moves 4 ALL GOOD
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
Total Moves 4 ALL GOOD
Code: 12:23:21 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:23:22 UTC,
py,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Analysis
expand all
Example tests
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
[654, 114, 25, 759, 281, 250, 228, 142, 754] Total Moves 4 ALL GOOD
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
[654, 114, 25, 759, 281, 250, 228, 142, 754] Total Moves 4 ALL GOOD
Code: 12:26:33 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:26:55 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = -1
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:27:07 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:27:17 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:27:20 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:27:25 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:27:37 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
min_row_id =
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:28:08 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
min_row_id = [i for i in range(3) if (row_sums[i] == row_min_sum)]
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:28:14 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
min_row_id = [i for i in range(3) if (row_sums[i] == row_min_sum)][0]
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:28:30 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
min_row_id = [i for i in range(3) if (row_sums[i] == row_min_sum)][0]
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
min_col_id = [i for i in range(3) if (row_sums[i] == row_min_sum)][0]
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:28:38 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
min_row_id = [i for i in range(3) if (row_sums[i] == row_min_sum)][0]
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
min_col_id = [i for i in range(3) if (col_sums[i] == c_min_sum)][0]
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:28:44 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
min_row_id = [i for i in range(3) if (row_sums[i] == row_min_sum)][0]
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
min_col_id = [i for i in range(3) if (col_sums[i] == col_min_sum)][0]
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:29:33 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
min_row_id = [i for i in range(3) if (row_sums[i] == row_min_sum)][0]
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
min_col_id = [i for i in range(3) if (col_sums[i] == col_min_sum)][0]
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:29:39 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
min_row_id = [i for i in range(3) if (row_sums[i] == row_min_sum)][0]
print(min_col_id)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
min_col_id = [i for i in range(3) if (col_sums[i] == col_min_sum)][0]
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:30:10 UTC,
py,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
min_row_id = [i for i in range(3) if (row_sums[i] == row_min_sum)][0]
print(min_col_id)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
min_col_id = [i for i in range(3) if (col_sums[i] == col_min_sum)][0]
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Analysis
expand all
Example tests
1.
0.040 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 141, in <module>
main()
File "exec.py", line 103, in main
result = solution( A )
File "/tmp/solution.py", line 98, in solution
exp()
File "/tmp/solution.py", line 91, in exp
A = solve_core(A)
File "/tmp/solution.py", line 15, in solve_core
print(min_col_id)
UnboundLocalError: local variable 'min_col_id' referenced before assignment
stdout:
[654, 114, 25, 759, 281, 250, 228, 142, 754]
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 98, in solution
exp()
File "/tmp/solution.py", line 91, in exp
A = solve_core(A)
File "/tmp/solution.py", line 15, in solve_core
print(min_col_id)
UnboundLocalError: local variable 'min_col_id' referenced before assignment
stdout:
[654, 114, 25, 759, 281, 250, 228, 142, 754]
Code: 12:30:34 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
min_row_id = [i for i in range(3) if (row_sums[i] == row_min_sum)][0]
print(min_row_id)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
min_col_id = [i for i in range(3) if (col_sums[i] == col_min_sum)][0]
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:30:36 UTC,
py,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
min_row_id = [i for i in range(3) if (row_sums[i] == row_min_sum)][0]
print(min_row_id)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
min_col_id = [i for i in range(3) if (col_sums[i] == col_min_sum)][0]
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Analysis
expand all
Example tests
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
[654, 114, 25, 759, 281, 250, 228, 142, 754] 0 Total Moves 4 ALL GOOD
1.
0.040 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
[654, 114, 25, 759, 281, 250, 228, 142, 754] 0 Total Moves 4 ALL GOOD
Code: 12:31:42 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
min_row_id = [i for i in range(3) if (row_sums[i] == row_min_sum)][0]
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
min_col_id = [i for i in range(3) if (col_sums[i] == col_min_sum)][0]
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:31:54 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
min_row_id = [i for i in range(3) if (row_sums[i] == row_min_sum)][0]
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
min_col_id = [i for i in range(3) if (col_sums[i] == col_min_sum)][0]
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:32:24 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
min_row_id = [i for i in range(3) if (row_sums[i] == row_min_sum)][0]
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
min_col_id = [i for i in range(3) if (col_sums[i] == col_min_sum)][0]
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:32:48 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
min_row_id = [i for i in range(3) if (row_sums[i] == row_min_sum)][0]
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
min_col_id = [i for i in range(3) if (col_sums[i] == col_min_sum)][0]
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:32:52 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
min_row_id = [i for i in range(3) if (row_sums[i] == row_min_sum)][0]
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
min_col_id = [i for i in range(3) if (col_sums[i] == col_min_sum)][0]
s = max(max(col_sums), max(row_sums))
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:33:15 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
min_row_id = [i for i in range(3) if (row_sums[i] == row_min_sum)][0]
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
min_col_id = [i for i in range(3) if (col_sums[i] == col_min_sum)][0]
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums == row_min_sum):
min_row_id = i
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:33:18 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
min_row_id = [i for i in range(3) if (row_sums[i] == row_min_sum)][0]
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
min_col_id = [i for i in range(3) if (col_sums[i] == col_min_sum)][0]
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] == row_min_sum):
min_row_id = i
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:33:39 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
min_row_id = [i for i in range(3) if (row_sums[i] == row_min_sum)][0]
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
min_col_id = [i for i in range(3) if (col_sums[i] == col_min_sum)][0]
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (row_sums[i] == row_min_sum):
min_row_id = i
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:33:46 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
min_row_id = [i for i in range(3) if (row_sums[i] == row_min_sum)][0]
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
min_col_id = [i for i in range(3) if (col_sums[i] == col_min_sum)][0]
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (row_sums[i] == row_min_sum):
min_row_id = i
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:33:49 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
min_row_id = [i for i in range(3) if (row_sums[i] == row_min_sum)][0]
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
min_col_id = [i for i in range(3) if (col_sums[i] == col_min_sum)][0]
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (row_sums[i] == row_min_sum):
min_row_id = i
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:33:51 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
min_row_id = [i for i in range(3) if (row_sums[i] == row_min_sum)][0]
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
min_col_id = [i for i in range(3) if (col_sums[i] == col_min_sum)][0]
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (row_sums[i] == row_min_sum):
min_row_id = i
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:34:04 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
min_row_id = [i for i in range(3) if (row_sums[i] == row_min_sum)][0]
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
min_col_id = [i for i in range(3) if (col_sums[i] == col_min_sum)][0]
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:34:10 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
min_row_id = [i for i in range(3) if (row_sums[i] == row_min_sum)][0]
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:34:16 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
#Identify rows and columns that need an increment
rows = set()
cols = set()
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:34:43 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
for i in range(3):
if (row_sums[i] != s):
rows.add(i)
if (col_sums[i] != s):
cols.add(i)
#print(rows)
#print(cols)
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:34:47 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(len(rows) > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:34:55 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = rows.pop()
cid = cols.pop()
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:35:05 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:35:30 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:35:58 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
#Find new min row
row_min_sum = min
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:36:08 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
#Find new min row
row_min_sum = min(row_sums)
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:36:26 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:36:38 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in ran]
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:36:51 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:36:59 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
min_col_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
if (row_sums[rid] != s):
rows.add(rid)
elif (col_sums[cid] != s):
cols.add(cid)
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:37:09 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
min_col_id = [i for i in range(3) if col_sums[i] == col_min_sum][0]
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:37:11 UTC,
py,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
min_col_id = [i for i in range(3) if col_sums[i] == col_min_sum][0]
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Analysis
expand all
Example tests
1.
5.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 5.000 sec.
1.
5.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 5.000 sec.
Code: 12:37:39 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[])
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
min_col_id = [i for i in range(3) if col_sums[i] == col_min_sum][0]
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:37:50 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] == s):
problem_row_cols -= 1
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
min_col_id = [i for i in range(3) if col_sums[i] == col_min_sum][0]
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:37:53 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] == s):
problem_row_cols -= 1
if (row_sums[rid] == s):
problem_row_cols -= 1
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
min_col_id = [i for i in range(3) if col_sums[i] == col_min_sum][0]
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:38:01 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] == s):
problem_row_cols -= 1
if (col_sums[cid] == s):
problem_row_cols -= 1
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
min_col_id = [i for i in range(3) if col_sums[i] == col_min_sum][0]
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:38:10 UTC,
py,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] == s):
problem_row_cols -= 1
if (col_sums[cid] == s):
problem_row_cols -= 1
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
min_col_id = [i for i in range(3) if col_sums[i] == col_min_sum][0]
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Analysis
expand all
Example tests
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
[654, 114, 25, 759, 281, 250, 228, 142, 754] Total Moves 4 ALL GOOD
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
[654, 114, 25, 759, 281, 250, 228, 142, 754] Total Moves 4 ALL GOOD
Code: 12:38:55 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] == s):
problem_row_cols -= 1
if (col_sums[cid] == s):
problem_row_cols -= 1
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
min_col_id = [i for i in range(3) if col_sums[i] == col_min_sum][0]
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1000):
A = []
for j in range(9):
A.append(randint(0, 1000))
print(A)
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:39:01 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] == s):
problem_row_cols -= 1
if (col_sums[cid] == s):
problem_row_cols -= 1
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
min_col_id = [i for i in range(3) if col_sums[i] == col_min_sum][0]
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1000):
A = []
for j in range(9):
A.append(randint(0, 1000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:39:02 UTC,
py,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] == s):
problem_row_cols -= 1
if (col_sums[cid] == s):
problem_row_cols -= 1
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
min_col_id = [i for i in range(3) if col_sums[i] == col_min_sum][0]
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1000):
A = []
for j in range(9):
A.append(randint(0, 1000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Analysis
expand all
Example tests
1.
0.080 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Tota
1.
0.080 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Tota
Code: 12:39:16 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] == s):
problem_row_cols -= 1
if (col_sums[cid] == s):
problem_row_cols -= 1
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
min_col_id = [i for i in range(3) if col_sums[i] == col_min_sum][0]
move_count += 1
#print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1000):
A = []
for j in range(9):
A.append(randint(0, 1000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:39:16 UTC,
py,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] == s):
problem_row_cols -= 1
if (col_sums[cid] == s):
problem_row_cols -= 1
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
min_col_id = [i for i in range(3) if col_sums[i] == col_min_sum][0]
move_count += 1
#print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1000):
A = []
for j in range(9):
A.append(randint(0, 1000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Analysis
expand all
Example tests
1.
0.076 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
ALL GOOD
1.
0.076 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
ALL GOOD
Code: 12:39:30 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] == s):
problem_row_cols -= 1
if (col_sums[cid] == s):
problem_row_cols -= 1
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
min_col_id = [i for i in range(3) if col_sums[i] == col_min_sum][0]
move_count += 1
#print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(1000):
A = []
for j in range(9):
A.append(randint(0, 100000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:39:39 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] == s):
problem_row_cols -= 1
if (col_sums[cid] == s):
problem_row_cols -= 1
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
min_col_id = [i for i in range(3) if col_sums[i] == col_min_sum][0]
move_count += 1
#print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(50):
A = []
for j in range(9):
A.append(randint(0, 1000000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:39:42 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] == s):
problem_row_cols -= 1
if (col_sums[cid] == s):
problem_row_cols -= 1
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
min_col_id = [i for i in range(3) if col_sums[i] == col_min_sum][0]
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(50):
A = []
for j in range(9):
A.append(randint(0, 1000000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:39:43 UTC,
py,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] == s):
problem_row_cols -= 1
if (col_sums[cid] == s):
problem_row_cols -= 1
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
min_col_id = [i for i in range(3) if col_sums[i] == col_min_sum][0]
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(50):
A = []
for j in range(9):
A.append(randint(0, 1000000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Analysis
expand all
Example tests
1.
0.040 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 ALL GOOD
1.
0.040 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 ALL GOOD
Code: 12:40:11 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] == s):
problem_row_cols -= 1
if (col_sums[cid] == s):
problem_row_cols -= 1
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
min_col_id = [i for i in range(3) if col_sums[i] == col_min_sum][0]
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(50):
A = []
for j in range(9):
A.append(randint(0, 10000000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:40:13 UTC,
py,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] == s):
problem_row_cols -= 1
if (col_sums[cid] == s):
problem_row_cols -= 1
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
min_col_id = [i for i in range(3) if col_sums[i] == col_min_sum][0]
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#colums
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(50):
A = []
for j in range(9):
A.append(randint(0, 10000000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Analysis
expand all
Example tests
1.
0.040 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 ALL GOOD
1.
0.040 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.stdout:
Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 Total Moves 4 ALL GOOD
Code: 12:40:50 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] == s):
problem_row_cols -= 1
if (col_sums[cid] == s):
problem_row_cols -= 1
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
min_col_id = [i for i in range(3) if col_sums[i] == col_min_sum][0]
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#columns
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(50):
A = []
for j in range(9):
A.append(randint(0, 10000000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
exp()
#solve_core(A)
Code: 12:41:25 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] == s):
problem_row_cols -= 1
if (col_sums[cid] == s):
problem_row_cols -= 1
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
min_col_id = [i for i in range(3) if col_sums[i] == col_min_sum][0]
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#columns
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(50):
A = []
for j in range(9):
A.append(randint(0, 10000000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
#exp()
#solve_core(A)
Code: 12:41:28 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] == s):
problem_row_cols -= 1
if (col_sums[cid] == s):
problem_row_cols -= 1
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
min_col_id = [i for i in range(3) if col_sums[i] == col_min_sum][0]
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#columns
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(50):
A = []
for j in range(9):
A.append(randint(0, 10000000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
#exp()
solve_core(A)
Code: 12:41:38 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] == s):
problem_row_cols -= 1
if (col_sums[cid] == s):
problem_row_cols -= 1
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
min_col_id = [i for i in range(3) if col_sums[i] == col_min_sum][0]
move_count += 1
print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#columns
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(50):
A = []
for j in range(9):
A.append(randint(0, 10000000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
#exp()
solve_core(A)
Code: 12:41:53 UTC,
py,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] == s):
problem_row_cols -= 1
if (col_sums[cid] == s):
problem_row_cols -= 1
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
min_col_id = [i for i in range(3) if col_sums[i] == col_min_sum][0]
move_count += 1
#print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#columns
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(50):
A = []
for j in range(9):
A.append(randint(0, 10000000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
#exp()
solve_core(A)
Analysis
expand all
Example tests
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, array expected, <class 'NoneType'> found.
Code: 12:41:53 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] == s):
problem_row_cols -= 1
if (col_sums[cid] == s):
problem_row_cols -= 1
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
min_col_id = [i for i in range(3) if col_sums[i] == col_min_sum][0]
move_count += 1
#print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#columns
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(50):
A = []
for j in range(9):
A.append(randint(0, 10000000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
#exp()
solve_core(A)
Code: 12:42:02 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] == s):
problem_row_cols -= 1
if (col_sums[cid] == s):
problem_row_cols -= 1
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
min_col_id = [i for i in range(3) if col_sums[i] == col_min_sum][0]
move_count += 1
#print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#columns
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(50):
A = []
for j in range(9):
A.append(randint(0, 10000000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
#exp()
retsolve_core(A)
Code: 12:42:05 UTC,
py,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] == s):
problem_row_cols -= 1
if (col_sums[cid] == s):
problem_row_cols -= 1
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
min_col_id = [i for i in range(3) if col_sums[i] == col_min_sum][0]
move_count += 1
#print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#columns
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(50):
A = []
for j in range(9):
A.append(randint(0, 10000000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
#exp()
return solve_core(A)
Analysis
Code: 12:42:58 UTC,
py,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] == s):
problem_row_cols -= 1
if (col_sums[cid] == s):
problem_row_cols -= 1
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
min_col_id = [i for i in range(3) if col_sums[i] == col_min_sum][0]
move_count += 1
#print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#columns
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(50):
A = []
for j in range(9):
A.append(randint(0, 10000000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
#exp()
return solve_core(A)
Analysis
Code: 12:43:00 UTC,
py,
final,
score:
100
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
from random import randint
def solve_core(A):
problem_row_cols = 0
#Step 1 find max sum
row_sums = []
row_sums.append(A[0] + A[1] + A[2])
row_sums.append(A[3] + A[4] + A[5])
row_sums.append(A[6] + A[7] + A[8])
row_min_sum = min(row_sums)
col_sums = []
col_sums.append(A[0] + A[3] + A[6])
col_sums.append(A[1] + A[4] + A[7])
col_sums.append(A[2] + A[5] + A[8])
col_min_sum = min(col_sums)
s = max(max(col_sums), max(row_sums))
for i in range(3):
if (row_sums[i] < s):
problem_row_cols += 1
if (col_sums[i] < s):
problem_row_cols += 1
if (row_sums[i] == row_min_sum):
min_row_id = i
if (col_sums[i] == col_min_sum):
min_col_id = i
#print("maximal sum", s)
#Step 2
move_count = 0
while(problem_row_cols > 0):
#Get row with the lowest sum
rid = min_row_id
cid = min_col_id
inc = s - max(row_sums[rid], col_sums[cid])
A[3*rid + cid] += inc
row_sums[rid] += inc
col_sums[cid] += inc
if (row_sums[rid] == s):
problem_row_cols -= 1
if (col_sums[cid] == s):
problem_row_cols -= 1
#Find new min row
row_min_sum = min(row_sums)
col_min_sum = min(col_sums)
min_row_id = [i for i in range(3) if row_sums[i] == row_min_sum][0]
min_col_id = [i for i in range(3) if col_sums[i] == col_min_sum][0]
move_count += 1
#print("Total Moves", move_count)
#print(A)
return A;
def evaluate(A):
#Step 1 find max sum
s = A[0] + A[1] + A[2]
for i in range(3):
#rows
if (A[3*i] + A[3*i + 1] + A[3*i + 2] != s):
return False
#columns
if (A[i] + A[i + 3] + A[i + 6] != s):
return False
return True
def exp():
A = 9 * [0]
for i in range(50):
A = []
for j in range(9):
A.append(randint(0, 10000000))
A = solve_core(A)
assert(evaluate(A))
print("ALL GOOD")
def solution(A):
#exp()
return solve_core(A)Analysis 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.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
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