# KellenWatt's solution

## to Spiral Matrix in the Go Track

Published at Apr 06 2020 · 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:

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

## Coding the solution

Look for a stub file having the name spiral_matrix.go and place your solution code in that file.

## 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

const (
Up = iota
Right
Down
Left
)

func SpiralMatrix(n int) [][]int {
mat := make([][]int, n)
for i:=0; i<n; i++ {
mat[i] = make([]int, n)
}

p := [2]int{0,0}
mod := [2]int{0,1}
dir := Right

for i:=1; i<=n*n; i++ {
row,col := p[0],p[1]
mat[row][col] = i
if col+mod[1] >= n || col+mod[1] < 0 ||
row+mod[0] >= n || row+mod[0] < 0 ||
mat[row + mod[0]][col + mod[1]] != 0 {
dir = (dir+1) % 4
switch dir {
case Up:
mod = [2]int{-1,0}
case Right:
mod = [2]int{0,1}
case Down:
mod = [2]int{1,0}
case Left:
mod = [2]int{0,-1}
}
}
p[0] += mod[0]
p[1] += mod[1]
}

return mat
}

### KellenWatt's Reflection

There's probably some sort of mathematical solution to this, but it didn't readily occur to me. Approaching this with a walker is easy enough, and it has relatively minimal overhead. Still O(n^2) complexity, just with a slightly larger coefficient than an equation.