Doit afficher: 1. Afficher les combinaisons uniques d'utilisateur et d'ID de produit pour tous les achats effectués par des utilisateurs avant qu'ils ne soient bannis. Trier d'abord par nom d'utilisateur, puis par SKU 2. Trouver les utilisateurs ayant effectué des achats pour un montant supérieur à 5000 roubles. Afficher leurs noms au format id utilisateur | prénom | nom | montant des achats

Для решения задачи на Go предположим, что у нас есть структура данных для покупок, пользователей и информации о бане. Примерный подход:

1. Создаем структуру для хранения информации о покупках, пользователях и банах.
2. Фильтруем покупки, совершенные до даты бана пользователя.
3. Собираем уникальные пары (пользователь, SKU).
4. Сортируем по имени пользователя, затем по SKU.
5. Для второй задачи суммируем покупки по пользователям и фильтруем по сумме > 5000.

Пример кода:

package main

import (
    "fmt"
    "sort"
    "time"
)

type Purchase struct {
    UserID   int
    SKU      string
    Amount   float64
    Date     time.Time
}

type User struct {
    ID        int
    FirstName string
    LastName  string
    BanDate   *time.Time // nil если не забанен
}

func main() {
    users := []User{
        {ID: 1, FirstName: "Ivan", LastName: "Ivanov", BanDate: parseDatePtr("2023-05-10")},
        {ID: 2, FirstName: "Anna", LastName: "Petrova", BanDate: nil},
    }

    purchases := []Purchase{
        {UserID: 1, SKU: "A123", Amount: 2000, Date: parseDate("2023-05-01")},
        {UserID: 1, SKU: "B456", Amount: 3500, Date: parseDate("2023-05-09")},
        {UserID: 1, SKU: "A123", Amount: 1500, Date: parseDate("2023-05-11")}, // после бана
        {UserID: 2, SKU: "C789", Amount: 6000, Date: parseDate("2023-05-05")},
    }

    // 1. Уникальные комбинации пользователь + SKU до бана
    type userSKU struct {
        UserName string
        SKU      string
    }
    uniqueMap := make(map[userSKU]struct{})

    userMap := make(map[int]User)
    for _, u := range users {
        userMap[u.ID] = u
    }

    for _, p := range purchases {
        user := userMap[p.UserID]
        if user.BanDate != nil && p.Date.After(*user.BanDate) {
            continue // покупка после бана
        }
        key := userSKU{UserName: user.FirstName, SKU: p.SKU}
        uniqueMap[key] = struct{}{}
    }

    var uniqueList []userSKU
    for k := range uniqueMap {
        uniqueList = append(uniqueList, k)
    }

    sort.Slice(uniqueList, func(i, j int) bool {
        if uniqueList[i].UserName == uniqueList[j].UserName {
            return uniqueList[i].SKU < uniqueList[j].SKU
        }
        return uniqueList[i].UserName < uniqueList[j].UserName
    })

    fmt.Println("Уникальные комбинации пользователя и SKU до бана:")
    for _, v := range uniqueList {
        fmt.Printf("%s | %s\n", v.UserName, v.SKU)
    }

    // 2. Пользователи с суммой покупок > 5000
    sumMap := make(map[int]float64)
    for _, p := range purchases {
        sumMap[p.UserID] += p.Amount
    }

    fmt.Println("\nПользователи с суммой покупок > 5000:")
    for id, sum := range sumMap {
        if sum > 5000 {
            u := userMap[id]
            fmt.Printf("%d | %s | %s | %.2f\n", u.ID, u.FirstName, u.LastName, sum)
        }
    }
}

func parseDate(s string) time.Time {
    t, _ := time.Parse("2006-01-02", s)
    return t
}

func parseDatePtr(s string) *time.Time {
    t := parseDate(s)
    return &t
}

Этот код демонстрирует логику решения обеих задач.