#include <iostream>
#include <algorithm>
#include <vector>
#include <array>
struct Point
{
size_t x;
size_t y;
Point() : x(0), y(0) {}
Point(size_t x, size_t y) : x(x), y(y) {}
Point operator+(const Point& p) const
{
return Point(x + p.x, y + p.y);
}
bool operator==(const Point& p) const
{
return x == p.x && y == p.y;
}
};
const std::array<Point, 4> clockwise {
Point(+1, 0), //right
Point(0, +1), //down
Point(-1, 0), //left
Point(0, -1), //up
};
const std::array<Point, 4> counterClockwise {
Point(0, +1), //down
Point(+1, 0), //right
Point(0, -1), //up
Point(-1, 0), //left
};
struct Grid
{
std::vector<std::vector<int>> grid;
size_t size;
Grid(size_t size)
{
this->size = size;
for(size_t i = 0; i < size; i++)
{
grid.push_back(std::vector<int>(size));
std::fill(grid[i].begin(), grid[i].end(), 0);
}
}
bool withinBounds(const Point& p)
{
return 0 <= p.x && p.x < size && 0 <= p.y && p.y < size;
}
void fill(bool reverse)
{
Point current(0, 0);
size_t directionIndex = 0;
auto direction = reverse ? counterClockwise : clockwise;
for(int number = 1, end = size * size; number <= end; number++)
{
grid[current.y][current.x] = number;
auto next = current + direction[directionIndex];
if(!withinBounds(next) || grid[next.y][next.x] != 0)
{
directionIndex = (directionIndex + 1) % 4;
next = current + direction[directionIndex];
}
current = next;
}
}
friend std::ostream& operator<<(std::ostream& out, const Grid& g);
};
std::ostream& operator<<(std::ostream& out, const Grid& g)
{
for(size_t y = 0; y < g.size; y++)
{
for(size_t x = 0; x < g.size; x++)
{
out << g.grid[y][x] << '\t';
}
out << std::endl;
}
return out;
}
int main()
{
int n;
std::string direction;
std::cin >> n;
std::cin >> direction;
Grid grid(n);
grid.fill(direction == "reverse");
std::cout << grid << std::endl;
}
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