go slice not behaving as expected [closed] - go

Question

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 3 years ago.
Improve this question
I was trying to get hands-on in slice and I observed that its not behaving as expected.
I was trying to get the cartesian product of n arrays of diff size. The output is not correct.
here is my code
func main() {
sl1 := []int{1,2,3}
sl2 := []int{4}
sl3 := []int{5,6}
sl4 := []int{8,9}
sl := [][]int{sl1,sl2,sl3,sl4}
res := cartesianMain(sl)
fmt.Println(res)
}
func cartesianMain(a [][]int) [][]int {
res := [][]int{}
for i:=0;i<len(a[0]) ;i++{
res = append(res,[]int{a[0][i]})
}
for i:= 1;i<len(a) ;i++{
res = cartesianProduct(res,a[i])
}
return res;
}
func cartesianProduct(a [][]int, b []int) [][]int {
result := [][]int{}
for _,v1 := range b {
for _,v2 := range a {
result = append(result, append(v2,v1))
}
}
return result
}
actual output:
[[1 4 5 9] [2 4 5 9] [3 4 5 9] [1 4 6 9] [2 4 6 9] [3 4 6 9] [1 4 5 9] [2 4 5 9] [3 4 5 9] [1 4 6 9] [2 4 6 9] [3 4 6 9]]
expected output:
if you see the sl4's 1st element 8 is over written by 9.
correct answer will be :
[[1 4 5 8] [2 4 5 8] [3 4 5 8] [1 4 6 8] [2 4 6 8] [3 4 6 8] [1 4 5 9] [2 4 5 9] [3 4 5 9] [1 4 6 9] [2 4 6 9] [3 4 6 9]]

Answer 1

This is becuase of how append works. In Go, slice is a header that keeps 3 property: Len, Cap, and Ptr. Len is the length of the slice it self, Cap is the capacity of the undrlying array of the slice (the memory), and Ptr is the pointer to the array.
When append appends to a slice where there are no more space in the underlying array, it allocates a new underlying array with some more space than needed and copies the content of the orignal slice into it and then adds the new element.
And When append appends to a slice where Cap > Len, i.e. where there are still sufficent space in the already allocated memory, append keeps the underlying array and copies the element to add to the a[Len+1] (where a is the underlying array). This will cause problem when two or more slice share the underlying memory.
A rule of thumb is to frequently check the need of copying a slice to avoid undesired sharing of underlying array.
To fix the problem, change result = append(result, append(v2,v1)) to result = append(result, append([]int{}, append(v2, v1)...)).
See also: https://blog.golang.org/slices
Note 1: append([]int{},append(v2,v1...)) is a shortcut of copy and apply. More tricks for slice can be found at: https://github.com/golang/go/wiki/SliceTricks .
Note 2: In Go, nil is a valid value for slice. so you can get rid of the seperation of split in cartesianMain by setting res to []int{nil}.
Note 3: For better performance and less allocations, it is a good practise to set the capacity (or length) for known slice. In cartesianProduct, you can use result := make([][]int, 0, len(a)*len(b)).
Playground: https://play.golang.org/p/rLqDGWoTLKS