Strange behavior when appending array to matrix

I'm missing something fundamental about slices that's causes my result to end up looking strange.

Yes this is a question from leetcode. I was using it to learn go because I find that solving algorithms in new languages is helpful to me. I don't need the answer to the algorithm and I don't need to know how to fix the algorithm. I just want to know why my appended value changes when I append another value.

First off here's my code:

type node struct {
    value int
    children []*node
}

func combinationSum(candidates []int, target int) [][]int {
    
    var output [][]int
    
    var acc []int
    
    combinationSum2(candidates, &output, target, acc, 0)
    
    return output
}

func combinationSum2(candidates []int, output *[][]int, target int, acc []int, sum int) {
    
    if(sum == target) {
        fmt.Println(acc)
        *output = append(*output, acc)
        fmt.Println(output)
        return
    }
    
    if(sum > target) {
        return
    }
    
    for i := 0; i < len(candidates); i++ {
        combinationSum2(candidates[i:], output, target, append(acc, candidates[i]), sum + candidates[i])
    }
    
}

I was testing this code with candidates=[2,3,5] and target=8

the correct output should be [[2,2,2,2],[2,3,3],[3,5]]; however, my code returns [[2,2,2,5],[2,3,3],[3,5]]

interestingly, when I log about the acc values in the if statement and the output after appending the acc value, it seems the the value that I appended changes after appending the second array.

acc = [2 2 2 2]
output = &[[2 2 2 2]]

acc = [2 3 3]
output = &[[2 2 2 5] [2 3 3]]

acc = [3 5]
output = &[[2 2 2 5] [2 3 3] [3 5]]

I tried running this locally, and get the same strange behavior. What's causing this?

As i wrote in the comment the problem in original code is with append usage in combinationSum2 function. The append was used to pass current acc extended by current candidate to combinationSum2 method.
I've added more logging to this function

func combinationSum2(candidates []int, output *[][]int, target int, acc []int, sum int) {
	if sum == target {
		fmt.Println("Acc:", acc)
		*output = append(*output, acc)
		fmt.Println("Output:", output)
		return
	}

	if sum > target {
		return
	}

	for i := 0; i < len(candidates); i++ {
		extendedAcc := append(acc, candidates[i])
		fmt.Printf("Extended: %v %p\n", extendedAcc, extendedAcc)
		combinationSum2(candidates[i:], output, target, extendedAcc, sum+candidates[i])
	}
}

and received following result (this is only few first interesting lines)

Extended: [2] 0x14000130008
Extended: [2 2] 0x14000130030
Extended: [2 2 2] 0x1400013c020
Extended: [2 2 2 2] 0x1400013c020
Acc: [2 2 2 2]
Output: &[[2 2 2 2]]
Extended: [2 2 2 3] 0x1400013c020
Extended: [2 2 2 5] 0x1400013c020
Extended: [2 2 3] 0x1400013c040
Extended: [2 2 3 3] 0x1400013c040

As you see the extendedAcc variable after it was added to Output still has the same address (they are printed as hex after the value). The final value for this address is [2 2 2 5] which is what you see in Output. The reason why it is not [2 2 3 3] is the result of how append works internally. In case when there is not enough space in current array it creates new one and returns a slice to it. And this behavior is visible when you compare the addresses of extended slice .

Here is properly working solution:

package main

import "fmt"

type node struct {
	value    int
	children []*node
}

func combinationSum(candidates []int, target int) [][]int {
	var output [][]int
	var acc []int
	combinationSum2(candidates, &output, target, acc, 0)
	return output
}

func combinationSum2(candidates []int, output *[][]int, target int, acc []int, sum int) {
	if sum == target {
		fmt.Println(acc)
		*output = append(*output, acc)
		fmt.Println(output)
		return
	}

	if sum > target {
		return
	}

	for i := 0; i < len(candidates); i++ {
		currentAcc := make([]int, 0, len(acc) + 1)
		currentAcc = append(currentAcc, acc...)
		currentAcc = append(currentAcc, candidates[i])
		combinationSum2(candidates[i:], output, target, currentAcc, sum+candidates[i])
	}
}

func main() {
	combinationSum([]int{2, 3, 5}, 8)
}

Alternatively the combinationSum2 function may look like this:

func combinationSum2(candidates []int, output *[][]int, target int, acc []int, sum int) {
	if sum == target {
		fmt.Println(acc)
		accCopy := make([]int, 0, len(acc))
		accCopy = append(accCopy, acc...)
		*output = append(*output, accCopy)
		fmt.Println(output)
		return
	}

	if sum > target {
		return
	}

	for i := 0; i < len(candidates); i++ {
		combinationSum2(candidates[i:], output, target, append(acc, candidates[i]), sum+candidates[i])
	}
}

Which in my opinion is less safe in general but will work properly for this problem.