Heap's algorithm to generate permutations

permutations.go

package main
/**
 * Word permutations using Heap's algorithm
 * http://en.wikipedia.org/wiki/Heap%27s_algorithm
 */
import (
    "fmt"
    "strings"
    "bytes"
)

/**
 * Wrapper function to convert string into an array and get it's length
 */
func permutations(word string) string {
    wordArray := strings.Fields(word)    
    generatedString := generate(len(wordArray)-1, wordArray)
    return generatedString    
}

/**
 * Main algorithm
 */
func generate (n int, A []string) string {
    var generatedString string
    var buffer bytes.Buffer    
    
    if n == 0 {
        buffer.WriteString(strings.Join(A, ", "))
        buffer.WriteString("\n")
        return buffer.String()

    } else {
        for i := 0; i <= n; i++ {
            buffer.WriteString(generatedString)
            buffer.WriteString(generate(n-1, A))

            // j = i if n is not odd.
            j := i            
            
            // If n is odd set j to zero
            if n % 2 != 0{
                j = 0
            } 

            A = swap(A, j, n)
        }
        
        return buffer.String()
    }
}

/**
 * Swap two elements in A i and n
 */
func swap (A []string, j int, n int) []string {
    // swap
    aj := A[j]
    an := A[n]
    A[j] = an
    A[n] = aj
    
    return A
}

func main() {
    fmt.Println(permutations("foo bar baz"))
}

the generated output will look like this:

foo, bar, baz
bar, foo, baz
baz, bar, foo
bar, baz, foo
baz, foo, bar
foo, baz, bar