[Skydiver]

I figured it was time for another C# challenge. The objective is to generate normal magic squares. A normal magic square is a NxN matrix filled with all the numbers from 1..N² and arranged such that the sum of each row, and the sum of each column is some constant number.

Here are some magic squares:

4 9 2
3 5 7
8 1 6

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

Input:
From the command line, a number N which is the size of the square.

Output:
To the console, a grid like shown above with the number arranged in a magic square.

Language:
C# preferred, but if you need to exercise your skills in another language, feel free to post.

For initial entries you only need to support odd values for N, just print out an message saying that you don't support even sizes. For those who want to be challenged support powers of 2 for N. For bragging rights, support all even numbers.

Be sure to post your code within spoiler tags to keep this challenge fresh for everyone.

This post has been edited by Skydiver: 29 September 2012 - 03:22 PM

[CasiOo]

Let me start with a "randomize until magic square" solution

Can only get better from here!

Works well with n == 3 or 4

Spoiler

using System;
using System.Threading.Tasks;
using System.Linq;

namespace MagicSquares {
    class Program {
        static void Main(string[] args) {
            new Program(int.Parse(args[0]));
        }

        private int n;
        private int constant;
        private int[,] solution;

        public Program(int n) {
            this.n = n;
            int nSquared = n * n;
            int sumAllNumbs = nSquared * (nSquared + 1) / 2;
            constant = sumAllNumbs / n;

            int threads = Environment.ProcessorCount;
            Parallel.For(0, threads, (i) => {
                Random rnd = new Random();
                int[] numbers = Enumerable.Range(1, nSquared).ToArray();
                int[,] square = new int[n, n];

                do {
                    RandomizeNumbers(rnd, numbers);
                    FillSquare(square, numbers);

                    if (IsMagicSquare(square))
                        solution = square;

                } while (solution == null);
            });

            PrintSquare(solution);
        }

        private void RandomizeNumbers(Random rnd, int[] numbers) {
            for (int i = numbers.Length - 1; i >= 0; i--) {
                int index = rnd.Next(numbers.Length);
                int temp = numbers[i];
                numbers[i] = numbers[index];
                numbers[index] = temp;
            }
        }

        private void FillSquare(int[,] square, int[] numbers) {
            int index = 0;
            for (int y = 0; y < n; y++)
                for (int x = 0; x < n; x++) {
                    square[y, x] = numbers[index];
                    index++;
                }
        }

        private bool IsMagicSquare(int[,] square) {
            //Check horizontal
            for (int y = 0; y < n; y++) {
                int sum = 0;
                for (int x = 0; x < n; x++)
                    sum += square[y, x];

                if (sum != constant)
                    return false;
            }

            //Check vertical
            for (int x = 0; x < n; x++) {
                int sum = 0;
                for (int y = 0; y < n; y++)
                    sum += square[y, x];

                if (sum != constant)
                    return false;
            }

            return true;
        }

        private void PrintSquare(int[,] square) {
            for (int y = 0; y < n; y++) {
                for (int x = 0; x < n; x++)
                    Console.Write(square[y, x] + " ");
                Console.WriteLine();
            }
        }
    }
}

[Momerath]

Short method that does odd squares using a simple pattern. Still working on even squares

Spoiler

static int[,] DoOddSquare(int n) {
    int[,] a = new int[n, n];
    int x = 0;
    int y = n/2;
    int limit = n * n;
    int value = 2;

    a[x, y] = 1;

    while (value <= limit) {
        int x1 = x == 0 ? n - 1 : x - 1;
        int y1 = (y + 1) % n;

        if (a[x1, y1] == 0) {
            x = x1;
            y = y1;
        } else {
            x = (x + 1) % n;
        }
        
        a[x, y] = value++;
    }

    return a;
}

[Skydiver]

Momerath that's nice, short and sweet. You may want to deal with the degenerate case where n == 1, though.

[Momerath]

Yeah, the outside code (that picks the even/odd routine) handles 1, didn't think about it here

[raghav.naganathan]

The idea is to make the sum as 'n [ ( n^2 + 1) / 2 ]' , in a [n*n] matix


say for eg. [3*3] matrix , n=3

so sum = 3[ (3^2 +1)/2]
= 3[ 10/2]
= 3*5
=15

regards,
Raghav

[psychopyro202]

I figured I would shed a little bit of light on this if anyone still wants to undergo this challenge.
Look here