Problem:
ぐるぐる模様

「ぐるぐる模様」を表示するプログラムを作成することにしました。「ぐるぐる模様」は以下のようなものとします。

1 辺の長さが n の場合、n 行 n 列の文字列として表示する。

左下隅を基点とし，時計回りに回転する渦状の模様とする。

線のある部分は #（半角シャープ）、空白部分は " "（半角空白）で表現する。

線と線の間は空白を置く。

整数 n を入力とし，1 辺の長さが n の「ぐるぐる模様」を出力するプログラムを作成してください。

Input

入力は以下の形式で与えられます。

d
n1
n2
:
nd

１行目にデータセットの数 d (d ≤ 20)、続く d 行に i 個目のぐるぐる模様の辺の長さ ni (1 ≤ ni ≤ 100) がそれぞれ１行に与えられます。

Output

データセットごとに、ぐるぐる模様を出力してください。データセットの間に１行の空行を入れてください。

Sample Input

2
5
6

Output for the Sample Input

#####
# #
# # #
# # #
# ###

######
# #
# ## #
# # #
# # #
# ####

Solution in C# (judge verdict: WA: Presentation Error)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    struct Position
    {
        internal int x, y;

        public Position(int x, int y)
        {
            this.x = x;
            this.y = y;
        }
    }

    class Program
    {
        static readonly int[] moveX = new int[] { 0, +1, 0, -1 };
        static readonly int[] moveY = new int[] { -1, 0, +1, 0 };

        static void Main(string[] args)
        {
            StringBuilder sb = new StringBuilder();

            int d = int.Parse(Console.ReadLine());

            while (d-- > 0)
            {
                int n = int.Parse(Console.ReadLine());

                char[][] map = new char[n][];

                map[0] = Enumerable.Repeat('#', n).ToArray();

                for (int i = 1; i < n; i++)
                {
                    map[i] = Enumerable.Repeat(' ', n).ToArray();
                }

                Position cur = new Position(0, n - 1);
                map[cur.y][cur.x] = '#';

                Position[] target = new Position[4];
                target[0] = new Position(0, 0);
                target[1] = new Position(n - 1, 0);
                target[2] = new Position(n - 1, n - 1);
                target[3] = new Position(2, n - 1);

                bool flg = true;

                while (flg)
                {
                    for (int i = 0; i < 4; i++)
                    {
                        int moveCount = 0;

                        while (!Equal(cur, target[i]))
                        {
                            cur.x += moveX[i];
                            cur.y += moveY[i];
                            moveCount++;

                            map[cur.y][cur.x] = '#';
                        }

                        if (moveCount <= 1)
                        {
                            flg = false;
                            break;
                        }
                    }

                    if (flg)
                    {
                        target[0] = new Position(target[0].x + 2, target[0].y + 2);
                        target[1] = new Position(target[1].x - 2, target[1].y + 2);
                        target[2] = new Position(target[2].x - 2, target[2].y - 2);
                        target[3] = new Position(target[3].x + 2, target[3].y - 2);
                    }
                }

                for (int i = 0; i < n; i++)
                {
                    for (int j = 0; j < n; j++)
                    {
                        sb.Append(map[i][j]);
                    }
                    sb.Append("\n");
                }
            }
            Console.Write(sb);
        }

        static bool Equal(Position a, Position b)
        {
            if (a.x != b.x) return false;
            if (a.y != b.y) return false;
            return true;
        }
    }
}