Pourquoi ces tuples ne sont-ils pas générés correctement ?

Éditeur PHP Apple rencontre souvent des problèmes lors de l'écriture de code. L'un des problèmes courants est la génération incorrecte de tuples. Cela peut être dû à des erreurs de logique de code, à des incompatibilités de types de données ou à d'autres erreurs. Avant de résoudre ce problème, nous devons analyser soigneusement le code, trouver les points d'erreur possibles et les résoudre un par un. Ce n'est que lorsque le problème est détecté que les réparations correspondantes peuvent être effectuées pour garantir que les tuples sont générés correctement afin d'assurer le fonctionnement normal du code.

Contenu de la question

J'ai travaillé sur un projet qui m'oblige à générer tous les tuples possibles d'une longueur spécifique à partir d'un ensemble de nombres (au pluriel). Pour ce faire, j'ai essayé d'implémenter une version de la commande Tuples[] de Mathematica, mais j'ai constaté qu'elle ne générait pas correctement tous les tuples.

Après beaucoup de frustration, j'ai découvert que lorsque mon programme génère des tuples de longueur 4, il ajoute des doublons au lieu de nouveaux éléments, provoquant des problèmes avec les tuples de plus longue longueur. J'ai regardé en ligne si quelqu'un avait d'autres problèmes similaires et j'ai trouvé un autre code pour accomplir la même tâche et j'ai remarqué que ma solution était similaire à la leur. Je ne sais pas ce qui ne va pas chez moi.

Après plus de frustration, j'ai découvert que si j'ajoute des éléments à la liste, tout fonctionne bien, seul l'ajout est le problème. J'ai essayé de comprendre ce qui n'allait pas avec mon code d'origine mais je n'ai rien trouvé.

Vous trouverez ci-dessous le code que j'ai écrit pour démontrer le problème. Je ne suis en aucun cas un codeur professionnel, vous devrez donc me pardonner si ce n'est pas la manière la plus idiomatique d'accomplir cette tâche. Actuellement, j'utilise la fonction tuplesByPrepend dans mon code actuel et cela fonctionne très bien, j'espère vraiment comprendre ce qui ne va pas avec la fonction tuplesByAppend. De même, il semblait bien fonctionner aux troisième, cinquième, huitième et à tout autre niveau sur lequel je l’ai testé. Je peux fournir plus d'informations sur mon système d'exploitation et ma build et tout ça si nécessaire.

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)
}

Workaround

Dans certains cas, la ligne suivante ne fonctionne pas comme prévu :

next := append(u, v)

Cet exemple montre ce qui se passe :

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)
}

Pour l'empêcher de partager le tableau sous-jacent, remplacez next :=append(u, v) par le code suivant :

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

Voir Go Slices : utilisation et composants internes pour plus d'informations.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!