 ## to Spiral Matrix in the Go Track

Published at Apr 20 2019 · 0 comments
Instructions
Test suite
Solution

Given the size, return a square matrix of numbers in spiral order.

The matrix should be filled with natural numbers, starting from 1 in the top-left corner, increasing in an inward, clockwise spiral order, like these examples:

###### Spiral matrix of size 3
``````1 2 3
8 9 4
7 6 5
``````
###### Spiral matrix of size 4
`````` 1  2  3 4
12 13 14 5
11 16 15 6
10  9  8 7
``````

## Running the tests

To run the tests run the command `go test` from within the exercise directory.

If the test suite contains benchmarks, you can run these with the `--bench` and `--benchmem` flags:

``````go test -v --bench . --benchmem
``````

Keep in mind that each reviewer will run benchmarks on a different machine, with different specs, so the results from these benchmark tests may vary.

## Further information

For more detailed information about the Go track, including how to get help if you're having trouble, please visit the exercism.io Go language page.

## Source

Reddit r/dailyprogrammer challenge #320 [Easy] Spiral Ascension. https://www.reddit.com/r/dailyprogrammer/comments/6i60lr/20170619_challenge_320_easy_spiral_ascension/

## Submitting Incomplete Solutions

It's possible to submit an incomplete solution so you can see how others have completed the exercise.

### spiral_matrix_test.go

``````package spiralmatrix

import (
"reflect"
"testing"
)

var testCases = []struct {
description string
input       int
expected    [][]int
}{
{
description: "empty spiral",
input:       0,
expected:    [][]int{},
},
{
description: "trivial spiral",
input:       1,
expected: [][]int{
{1},
},
},
{
description: "spiral of size 2",
input:       2,
expected: [][]int{
{1, 2},
{4, 3},
},
},
{
description: "spiral of size 3",
input:       3,
expected: [][]int{
{1, 2, 3},
{8, 9, 4},
{7, 6, 5},
},
},
{
description: "spiral of size 4",
input:       4,
expected: [][]int{
{1, 2, 3, 4},
{12, 13, 14, 5},
{11, 16, 15, 6},
{10, 9, 8, 7},
},
},
}

func TestSpiralMatrix(t *testing.T) {
for _, testCase := range testCases {
matrix := SpiralMatrix(testCase.input)
if !reflect.DeepEqual(matrix, testCase.expected) {
t.Fatalf("FAIL: %s\n\tSpiralMatrix(%v)\nexpected: %v\ngot     : %v",
testCase.description, testCase.input, testCase.expected, matrix)
}
t.Logf("PASS: %s", testCase.description)
}
}

func BenchmarkSpiralMatrix(b *testing.B) {
for i := 0; i < b.N; i++ {
for _, testCase := range testCases {
SpiralMatrix(testCase.input)
}
}
}``````
``````package spiralmatrix

type Dir int

const (
Right Dir = 0
Down  Dir = 1
Left  Dir = 2
Up    Dir = 3
)

type Coord struct {
row int
col int
}

type Matrix struct {
size  int
self  [][]int
dir   Dir
coord *Coord
}

func NewMatrix(size int) *Matrix {
mx := make([][]int, size)
for row := 0; row < size; row++ {
mx[row] = make([]int, size)
}
return &Matrix{
size:  size,
self:  mx,
dir:   Right,
coord: &Coord{0, 0},
}
}

func delta(dir Dir) *Coord {
switch dir {
case Right:
return &Coord{0, 1}
case Down:
return &Coord{1, 0}
case Left:
return &Coord{0, -1}
default:
return &Coord{-1, 0}
}
}

func (c *Coord) Add(other *Coord) {
c.row = c.row + other.row
c.col = c.col + other.col
}

func (m *Matrix) Turn() bool {
clone := &Coord{m.coord.row, m.coord.col}
if clone.row < 0 || clone.row >= m.size {
return true
}
if clone.col < 0 || clone.col >= m.size {
return true
}
if m.self[clone.row][clone.col] != 0 {
return true
}
return false
}

func (m *Matrix) Proceed() {
for i := 1; i <= m.size*m.size; i++ {
m.self[m.coord.row][m.coord.col] = i
if m.Turn() {
m.dir = (m.dir + 1) % 4
}
}
}

func SpiralMatrix(size int) (matrix [][]int) {
mt := NewMatrix(size)
mt.Proceed()
return mt.self
}``````