20

I am trying to create a 2d array in Go:

board := make([][]string, m)
for i := range board {
    board[i] = make([]string, n)
}

However, given the verbosity of that, I am wondering if there is a better or more succinct way to handle this problem (either to generate dynamic arrays, or a different/idiomatic data-structure to handle such board-game like data)?

Background:

  • this is for a board game
  • the dimensions of the board are not known until a user starts playing (so, say, MxN).
  • I want to store an arbitrary character (or a single char string) in each cell. In my TicTacToe game that will be the 'X' or an 'O' (or any other character the user chooses).
Improve this question
5
  • possible duplicate of Dynamically initialize array size in go Commented May 26, 2014 at 12:09
  • I've usually seen this handled by using slice literals to define the starting size and position for the board (arbitrary, it can be expanded using append), then modify that. See blog.golang.org/go-slices-usage-and-internals . Commented May 26, 2014 at 12:10
  • @msw That Q is from Dec'11. Also, it suggests what I did as the answer. I am pondering if there's a better way. Commented May 26, 2014 at 12:13
  • @Intermernet thanks. So, make indeed creates slices. Would you mind expanding on your suggestion (perhaps as an answer) by showing how append can be used in this case. Commented May 26, 2014 at 12:15
  • You could use runes instead of strings if you will only store 1 character. Commented May 26, 2014 at 14:36

3 Answers 3

Reset to default
17

What you are building in your sample code is not a 2D array, but rather a slice of slices: each of the sub-slices could be of a different length with this type, which is why you have separate allocations for each.

If you want to represent the board with a single allocation though, one option would be to allocate a single slice, and then use simple arithmetic to determine where elements are. For example:

board := make([]string, m*n)
board[i*m + j] = "abc" // like board[i][j] = "abc"
Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

This is a much better solution than a slice of slices. Thanks for the tip, I'll be using it myself!
9

The way you described creates a slice of slices, which looks similar to a 2d array that you want. I would suggest you to change the type to uint8, as you only care about 3 states nothing / first / second player.

This allocates each row separately (you will see at least m + 1 allocs/op in your benchmarks). This is not really nice because there is no guarantee that the separate allocations would be localized close to each other.

To maintain locality you can do something like this:

M := make([][]uint8, row)
e := make([]uint8, row * col)
for i := range M {
    a[i] = e[i * col:(i + 1) * col]
}

This will end up with only 2 allocations and the slice of slices will maintain data locality. Note that you will still be able to access your M in 2d format M[2][6].

A good video which explains how to do this even faster.

Improve this answer

Comments

5

For a multi dimensional array, we can have any of the 2 uses cases,

  1. You know the dimensions of array while compiling
  2. You get to know the array dimension only at runtime, ie may from the user input or so

For use case 1

matr := [5][5]int{}

For use case 2

var m, n int
fmt.Scan(&m, &n)
var mat = make([][]int, m)
for i := range mat {
    mat[i] = make([]int, n)
    fmt.Printf("Row %d: %v\n", i, mat[i])
}

In short, we have to rely on make for creating dynamic arrays

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.