Engee documentation
Notebook

A magic square with odd-sized sides

A magic square in size – this is a matrix filled with integers from 1 to so that the sum of the numbers along each row, each column, and the main diagonals are the same and equal .

The algorithm for solving the problem

Siamese method filling a magic square of the size (where an odd number) It consists of the following steps:

  1. Select a cell in the middle of the top row, accept
  2. Place in the selected cell
  3. If This means that the square is filled in and you can exit the procedure. Otherwise, increase per unit
  4. Move to the cell above and to the right of the current one. Go to the first column or the last row when leaving the matrix. If the new cell is already filled with a non-zero number, go back and instead move 1 cell lower (vertically).
  5. Go back to step 2
In [ ]: 
Pkg.add(["Colors", "LinearAlgebra"])
In [ ]: 
N = 7

magic_square = Matrix{Int}(zeros(N,N))

n = 1
i = 1
j = N ÷ 2

while n <= N^2
    magic_square[i, j] = n
    n += 1
    newi, newj = mod1((i-1), N), mod1((j+1), N)
    if magic_square[newi, newj] > 0
        i = mod1( i+1, N )
    else
        i, j = newi, newj
    end
end

display( magic_square )

7×7 Matrix{Int64}:
 39  48   1  10  19  28  30
 47   7   9  18  27  29  38
  6   8  17  26  35  37  46
 14  16  25  34  36  45   5
 15  24  33  42  44   4  13
 23  32  41  43   3  12  21
 31  40  49   2  11  20  22
In [ ]: 
gr()
heatmap( magic_square, c=:Greens, size=(200,200), cbar=:false,
         xticks=false, yticks=false )

# Вычислим координаты, текст и цвет надписей
vec_coords = CartesianIndices( size(magic_square) )
ax = first.( Tuple.(vec_coords[:]) )
ay = last.( Tuple.(vec_coords[:]) )
az = reshape( magic_square, 1, : )
acol = [ n > (N^2)÷2 ? (:white) : (:black) for n in az ]

# Нанесем на график надписи
for (x,y,z,c) in zip(ax,ay,az,acol)
    annotate!( x, y, text("$(convert(Int64, round(z)))",9,"Helvetica",c) );
end
plot!()
Out[0]:
39 47 6 14 15 23 31 48 7 8 16 24 32 40 1 9 17 25 33 41 49 10 18 26 34 42 43 2 19 27 35 36 44 3 11 28 29 37 45 4 12 20 30 38 46 5 13 21 22

Let's check that we got exactly the magic square. Here is the sum for all columns:

In [ ]: 
sum.( eachcol( magic_square ) )
Out[0]:
7-element Vector{Int64}:
 175
 175
 175
 175
 175
 175
 175

The sum of all lines:

In [ ]: 
sum.( eachrow( magic_square ) )
Out[0]:
7-element Vector{Int64}:
 175
 175
 175
 175
 175
 175
 175

The sum of the numbers on the main diagonal:

In [ ]: 
using LinearAlgebra
sum( diag( magic_square) )
Out[0]:
175

The sum of the numbers on the side diagonal:

In [ ]: 
sum( diag( magic_square') )
Out[0]:
175

Let's check all the conditions at once:

In [ ]: 
using Colors

verdict = all( vcat( sum.( eachcol( magic_square ) ), 
           sum.( eachrow( magic_square ) ),
           sum( diag( magic_square) ),
           sum( diag( magic_square') ) ) .== N*(N^2 + 1) ÷ 2 )

if verdict == true display( colorant"green" ) else display( colorant"red" ); end;
No description has been provided for this image

If we set an even value these conditions will not be satisfied (the result will be false).

Conclusion

We have implemented a procedure for constructing a magic square with some limitations. It embodies a fairly simple algorithm, and studying it is definitely useful for developing intuition in the field of programming.