What is the c plus plus program for magic square?

Answer 1

#include<iostream>

#include<vector>

#include<cassert>

class magic_square

{

friend std::ostream& operator<< (std::ostream&, const magic_square&);

private:

size_t dim;

std::vector<std::vector<size_t>> elem;

public:

magic_square (const size_t);

magic_square (const magic_square& m): dim {m.dim}, elem {m.elem} {}

magic_square (magic_square&& m): dim {m.dim}, elem {std::move (m.elem)} {}

size_t size () const { return dim*dim; }

size_t order () const { return dim; }

size_t* operator[] (const size_t);

#ifndef NDEBUG

bool assert_valid();

#endif DEBUG

};

magic_square::magic_square (const size_t order): dim {order}, elem {}

{

if (dim < 3)

throw std::range_error ("Magic square's must have an order greater than 2");

elem.resize (dim);

for (size_t row=0; row!=dim; ++row)

elem[row].resize(dim);

switch (dim % 4)

{

case (0):

{

size_t box = dim / 4;

size_t lower = 1;

size_t upper = dim * dim;

for (size_t x=0; x!=dim; ++x)

{

size_t row = x+1;

for (size_t y=0; y!=dim; ++y)

{

size_t col = y+1;

if (((row<=box row>dim-box) && (col<=box col>dim-box))

((row>box && row<=dim-box) && (col>box && col<=dim-box)))

elem[x][y] = lower;

else

elem[x][y] = upper;

++lower;

--upper;

}

}

}

break;

case (1):

case (3):

{

size_t num=0;

size_t row=0;

size_t col=(dim-1)/2;

while (num<dim*dim)

{

elem[row][col] = ++num;

size_t new_row = !row?dim:row-1;

size_t new_col = col+1;

if (new_row==dim)

{

if (new_col==dim)

{

new_col=col;

--new_row;

}

else

new_row=dim-1;

}

else if (new_col==dim)

new_col=0;

if (elem[new_row][new_col]!=0)

{

new_row=row+1;

new_col=col;

}

row = new_row;

col = new_col;

}

}

break;

case (2):

{

size_t num = 0;

size_t quarter = dim / 2;

magic_square temp (quarter);

for (size_t loop=0; loop!=4; ++loop)

{

num = loop * quarter * quarter;

switch (loop)

{

case (0):

for (size_t row=0; row!=quarter; ++row)

for (size_t col=0; col!=quarter; ++col)

{

elem[row][col] = temp.elem[row][col] + num;

}

break;

case (1):

for (size_t row=quarter; row!=dim; ++row)

for (size_t col=quarter; col!=dim; ++col)

{

size_t x = row-quarter;

size_t y = col-quarter;

elem[row][col] = temp.elem[x][y] + num;

}

break;

case (2):

for (size_t row=0; row!=quarter; ++row)

for (size_t col=quarter; col!=dim; ++col)

{

size_t x = row;

size_t y = col-quarter;

elem[row][col] = temp.elem[x][y] + num;

}

break;

case (3):

for (size_t row=quarter; row!=dim; ++row)

for (size_t col=0; col!=quarter; ++col)

{

size_t x = row-quarter;

size_t y = col;

elem[row][col] = temp.elem[x][y] + num;

}

break;

}

}

size_t div = (quarter-1) / 2;

for (size_t row=0; row!=quarter; ++row)

{

size_t min_col=row==div?1:0;

size_t max_col=row==div?div+1:div;

for (size_t col=min_col; col!=max_col; ++col)

std::swap (elem[row][col], elem[row+quarter][col]);

}

if (div=div-1)

{

for (size_t row=0; row!=quarter; ++row)

{

for (size_t col=dim-div; col!=dim; ++col)

{

std::swap (elem[row][col], elem[row+quarter][col]);

}

}

}

}

break;

}

#ifndef NDEBUG

assert_valid();

#endif NDEBUG

}

#ifndef NDEBUG

bool magic_square::assert_valid()

{

size_t old_sum = 0;

size_t sum = 0;

for (size_t row=0; row!=dim; ++row)

{

sum = 0;

for (size_t col=0; col!=dim; ++col)

sum += elem[row][col];

if (!old_sum)

old_sum = sum;

assert (old_sum sum);

return true;

}

#endif NDEBUG

std::ostream& operator<< (std::ostream& os, const magic_square& s)

{

for (size_t x=0; x!=s.dim; ++x)

{

for (size_t y=0; y!=s.dim; ++y)

{

os << s.elem[x][y] << '\t';

}

os << '\n';

}

return os;

}

int main()

{

std::cout << "Magic square of order 3\n" << magic_square (3) << std::endl;

std::cout << "Magic square of order 4\n" << magic_square (4) << std::endl;

std::cout << "Magic square of order 6\n" << magic_square (6) << std::endl;

}