Recursion 如何在GO的切片中存储递归获得的组合？

可以使用以下递归代码打印组合（灵感来自）

我认为将中间结果存储在[]int中或将组合集存储在[][]int中是很容易的。但是，由于该函数是递归的，因此它并不比替换

fmt.Println(s)

借

例如，对函数输出进行轻微修改。我还试着给一个指针，比如

p *[][]int

在递归函数中使用变量“s”，但我失败了：-/

我认为这是递归函数的一个普遍问题，所以如果你有一些建议来解决这个问题，它将帮助我很多

非常感谢！；）

主程序包
进口(
“fmt”
)
func main（）{
梳子（5，3）
}
函数梳（n，m int）{
s:=make（[]整数，m）
最后：=m-1
var rc func（int，int）
rc=func（i，下一个int）{
对于j:=next；j

在我看来，

s

被每个

rc

调用重用，因此您只需确保在将

s

存储到

[]]int

中时存储其副本，以便在下一次迭代中不会覆盖其内容

要复制一个切片，可以像这样使用append：

scopy := append([]int{}, s...)

主程序包
进口(
“fmt”
)
func main（）{
out:=梳（5,3）
fmt.Println（输出）
}
函数组合（n，m int）（out[][]int）{
s:=make（[]整数，m）
最后：=m-1
var rc func（int，int）
rc=func（i，下一个int）{
对于j:=next；j

Nice solution@mkopriva！谢谢

package main

import (
    "fmt"
)

func main() {

    comb(5, 3)
}

func comb(n, m int) {

    s := make([]int, m)
    last := m - 1
    var rc func(int, int)
    rc = func(i, next int) {
        for j := next; j < n; j++ {
            s[i] = j
            if i == last {
                fmt.Println(s)  
            } else {
                rc(i+1, j+1)
            }
        }
        return 
    }
    rc(0, 0)
}

scopy := append([]int{}, s...)

package main

import (
    "fmt"
)

func main() {

    out := comb(5, 3)
    fmt.Println(out)
}

func comb(n, m int) (out [][]int) {

    s := make([]int, m)
    last := m - 1

    var rc func(int, int)
    rc = func(i, next int) {

        for j := next; j < n; j++ {
            s[i] = j
            if i == last {
                out = append(out, append([]int{}, s...))
            } else {
                rc(i+1, j+1)
            }
        }
        return
    }
    rc(0, 0)

    return out
}