Comment regrouper et additionner des tranches de structures dans Go ?

Regrouper et additionner des tranches de structures dans Go

Le problème

En programmation, il est souvent nécessaire d'effectuer des tâches de manipulation de données en mémoire collections. Une opération courante consiste à regrouper les données en catégories et à additionner les valeurs au sein de chaque catégorie. Ce problème est souvent rencontré lorsque l'on travaille avec des tranches de structures.

Le défi

Considérons la tranche de structures suivante :

<code class="go">type Register struct {
    id1 int
    id2 int
    id3 int
    id4 int
    id5 int
    id6 int
    id7 int
    id8 int
    money int
}</code>

La tâche consiste à regrouper les éléments dans la tranche par les huit premiers champs (les champs d'identification) et la somme des champs d'argent pour chaque groupe. Cette opération est analogue à la requête SQL :

<code class="sql">SELECT SUM(money) FROM Registers GROUP BY id1, id2, id3, id4, id5, id6, id7, id8;</code>

La solution

Il existe plusieurs façons d'aborder ce problème dans Go. Une option consiste à utiliser une table de hachage pour suivre les sommes de chaque combinaison unique de champs d'identification.

1. Créez un type de clé : Définissez une nouvelle structure appelée Clé qui contient uniquement le champs d'identification. Cette structure servira d'identifiant unique pour chaque groupe.
2. Transformez les registres : Créez une nouvelle tranche où chaque élément est une structure avec un champ clé et un champ monétaire. Le champ Clé sera défini sur la clé correspondante de l'élément et le champ Argent restera inchangé.
3. Initialiser une carte : Créez une carte qui mappe les valeurs clés à des sommes entières.
4. Itérer et accumuler : Itérer sur la tranche transformée. Pour chaque élément, récupérez la somme de la carte à l'aide de la clé de l'élément, ajoutez le champ monétaire de l'élément et stockez la somme mise à jour dans la carte.

Le code suivant illustre cette approche :

<code class="go">type Key struct {
    id1 int
    id2 int
    id3 int
    id4 int
    id5 int
    id6 int
    id7 int
    id8 int
}

func groupAndSum(registers []*Register) map[Key]int {
    m := map[Key]int{}
    for _, r := range registers {
        key := Key{
            id1: r.id1,
            id2: r.id2,
            id3: r.id3,
            id4: r.id4,
            id5: r.id5,
            id6: r.id6,
            id7: r.id7,
            id8: r.id8,
        }
        m[key] += r.money
    }
    return m
}</code>

Cette solution fournit un moyen efficace de regrouper et de sommer des structures en fonction de leurs clés.

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!