# lubayer's solution

## to Spiral Matrix in the Go Track

Published at Oct 13 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 generates spiral matrixes
package spiralmatrix

// SpiralMatrix generates spiral matrixes
func SpiralMatrix(input int) [][]int {
if input <= 0 {
return [][]int{}
}

if input == 1 {
return [][]int{{1}}
}

output := make([][]int, input)

for i := 0; i < input; i++ {
output[i] = make([]int, input)
}

currentNum := 1
currentSpiral := -1

for {
currentSpiral++
for i := currentSpiral; i < input-currentSpiral; i++ {
if output[currentSpiral][i] != 0 {
return output
}
output[currentSpiral][i] = currentNum
currentNum++
if currentNum > input*input {
return output
}
}

for j := currentSpiral + 1; j < input-currentSpiral; j++ {
if output[j][input-1-currentSpiral] != 0 {
return output
}
output[j][input-1-currentSpiral] = currentNum
currentNum++
if currentNum > input*input {
return output
}
}

for i := input - 2 - currentSpiral; i >= currentSpiral; i-- {
if output[input-1-currentSpiral][i] != 0 {
return output
}
output[input-1-currentSpiral][i] = currentNum
currentNum++
if currentNum > input*input {
return output
}
}

for j := input - 2 - currentSpiral; j > currentSpiral; j-- {
if output[j][currentSpiral] != 0 {
return output
}
output[j][currentSpiral] = currentNum
currentNum++
if currentNum > input*input {
return output
}
}
}
}``````