为何生成这些元组未成功？

最近发现不少小伙伴都对Golang很感兴趣，所以今天继续给大家介绍Golang相关的知识，本文《为何生成这些元组未成功？》主要内容涉及到等等知识点，希望能帮到你！当然如果阅读本文时存在不同想法，可以在评论中表达，但是请勿使用过激的措辞~

我一直在从事一个项目，该项目要求我从一组（复数）数字生成特定长度的所有可能的元组。为此，我尝试实现 Mathematica Tuples[] 命令的一个版本，但发现它没有正确生成所有元组。

经过多次挫折，我发现当我的程序生成长度为 4 的元组时，它会添加重复项而不是新元素，从而导致任何更长长度的元组出现问题。我在网上查看是否有人有任何其他类似的问题，然后找到了一些其他代码来完成相同的任务，并注意到我的解决方案与他们的类似。我不知道自己哪里出了问题。

经过更多的挫折后，我发现如果我将元素添加到列表中，一切都会正常工作，只有附加才是问题所在。我试图找出我的原始代码有什么问题，但一无所获。

下面是我为演示该问题而编写的代码。我绝不是一个专业的编码员，所以如果这不是完成这项任务的最惯用的方法，你必须原谅我。目前，我在实际代码中使用 tuplesByPrepend 函数，它工作得很好，我真的只是希望了解 tuplesByAppend 函数出了什么问题。同样，在我测试过的第三、第五、第八和任何其他级别上，它似乎都表现良好。如果需要的话，我可以提供有关我的操作系统和构建以及所有这些的更多信息。

package main

import "fmt"

func tuplesByAppend[T any](list []T, depth int) [][]T {
    var l1 [][]T
    var l2 [][]T

    for _, v := range list {
        l1 = append(l1, []T{v})
    }

    for i := 1; i < depth; i++ {
        for _, u := range l1 {
            for _, v := range list {
                // Differs here
                next := append(u, v)
                // next is calculated properly, but added to l2 incorrectly at the fourth level only
                // at the fifth level it functions properly
                // fmt.Println(next)
                l2 = append(l2, next)
                // fmt.Println(l2)

                // it appears that at the fourth level it is writing over the previous entries
                // Printing here yields
                // [[1 1 1 1]]
                // [[1 1 1 2] [1 1 1 2]]
                // [[1 1 1 3] [1 1 1 3] [1 1 1 3]]
                // [[1 1 1 3] [1 1 1 3] [1 1 1 3] [1 1 2 1]]
                // [[1 1 1 3] [1 1 1 3] [1 1 1 3] [1 1 2 2] [1 1 2 2]]
                // and so on.
            }
        }
        l1 = l2
        l2 = [][]T{}
    }

    return l1
}

func tuplesByPrepend[T any](list []T, depth int) [][]T {
    var l1 [][]T
    var l2 [][]T

    for _, v := range list {
        l1 = append(l1, []T{v})
    }

    for i := 1; i < depth; i++ {
        for _, u := range l1 {
            for _, v := range list {
                // Differs here
                next := append([]T{v}, u...)
                l2 = append(l2, next)
            }
        }
        l1 = l2
        l2 = [][]T{}
    }

    return l1
}

func main() {
    ourlist := []int{1, 2, 3}
    ourdepth := 4
    appended := tuplesByAppend(ourlist, ourdepth)
    prepended := tuplesByPrepend(ourlist, ourdepth)

    // We should expect this slice to start [1 1 1 1] [1 1 1 2] [1 1 1 3] [1 1 2 1] ...
    // In fact, it starts                   [1 1 1 3] [1 1 1 3] [1 1 1 3] [1 1 2 3]
    fmt.Println(appended)
    // This slice is as expected
    fmt.Println(prepended)
}

正确答案

在某些情况下，以下行无法按您的预期工作：

next := append(u, v)

此示例演示了发生的情况：

package main

import "fmt"

func main() {
    u := append([]int{1, 2}, 3)
    // The length is 3 but the capacity is 4.
    fmt.Printf("u %v\n  len: %d\n  cap: %d\n", u, len(u), cap(u))

    // Since u has enough capacity for the new element "4",
    // v1 will share the same underlying array.
    v1 := append(u, 4)
    fmt.Println("v1:", v1)

    // As what happened to v1, v2 will share the same underlying array too.
    // But the last element "4" in the underlying array is changed to "5".
    v2 := append(u, 5)
    fmt.Println("v2:", v2)

    // Since v1 uses the same underlying array, it sees the change in the last step.
    fmt.Println("v1:", v1)
}

要防止它共享底层数组，请将 next :=append(u, v) 替换为以下代码：

next := make([]T, len(u)+1)
copy(next, u)
next[len(u)] = v

请参阅 Go Slices：用法和内部原理了解更多信息。

今天关于《为何生成这些元组未成功？》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！