solving a boggle problem in go

board.go

package main

import "fmt"

func main() {
	var board = [][]byte{
		[]byte{'A', 'B', 'C', 'E'},
		[]byte{'S', 'F', 'C', 'S'},
		[]byte{'A', 'D', 'E', 'E'},
	}
	var tests = map[string]bool{
		"ABCCED": true,
		// "SEE":    true,
		// "ABCB":   false,
	}
	for t, e := range tests {
		a := exist(board, t)
		if a == e {
			fmt.Printf("PASSED: Given %v expected %v actual %v\n", t, e, exist(board, t))
		} else {
			fmt.Printf("FAILED: Given %v expected %v actual %v\n", t, e, exist(board, t))
		}
	}
}

func exist(board [][]byte, word string) bool {
	for r, row := range board {
		for c := range row {
			if visit(board, word, newVisited(board), r, c) {
				return true
			}
		}
	}
	return false
}

func visit(board [][]byte, word string, visited [][]bool, row, col int) bool {
	if board[row][col] != word[0] {
		// fmt.Println("Current char isnt right bailing")
		return false
	}
	// fmt.Printf("Match on %v,%v on word %v, visited is %v\n", row, col, word, visited)
	if len(word) == 1 {
		return true
	}
	visited[row][col] = true
	a := getUnvisitedAdjacents(board, visited, row, col)
	if len(a) == 0 {
		// fmt.Println("No available adjacents, bailing")
		return false
	}
	for _, p := range a {
		if visit(board, word[1:], visited, p[0], p[1]) {
			return true
		}
		visited[p[0]][p[1]] = false
	}
	// fmt.Println("All children bailed, bailing")
	return false
}

func newVisited(board [][]byte) [][]bool {
	r := make([][]bool, len(board))
	for i, row := range board {
		r[i] = make([]bool, len(row))
	}
	return r
}

func getUnvisitedAdjacents(board [][]byte, visited [][]bool, row, col int) [][]int {
	a := getAdjacents(board, row, col)
	r := [][]int{}
	for _, p := range a {
		if !visited[p[0]][p[1]] {
			r = append(r, p)
		}
	}
	return r
}

func getAdjacents(board [][]byte, row, col int) [][]int {
	// Assumes a valid row and col
	ret := [][]int{}
	if row > 0 {
		ret = append(ret, []int{row - 1, col})
		if col > 0 {
			ret = append(ret, []int{row - 1, col - 1})
		}
		if col < len(board[row])-1 {
			ret = append(ret, []int{row - 1, col + 1})
		}
	}
	if row < len(board)-1 {
		ret = append(ret, []int{row + 1, col})
		if col > 0 {
			ret = append(ret, []int{row + 1, col - 1})
		}
		if col < len(board[row])-1 {
			ret = append(ret, []int{row + 1, col + 1})
		}
	}
	if col > 0 {
		ret = append(ret, []int{row, col - 1})
	}
	if col < len(board[row])-1 {
		ret = append(ret, []int{row, col + 1})
	}
	return ret
}