sort.Interface

Fait partie de la section Programmation Orientée Objet du Journey GO de Coddy. Leçon 74 sur 107.

Le package sort fournit un autre excellent exemple de conception fondée sur les interfaces. Pour trier une collection personnalisée, votre type doit implémenter sort.Interface :

type Interface interface {
    Len() int
    Less(i, j int) bool
    Swap(i, j int)
}

Ces trois méthodes fournissent à l’algorithme de tri tout ce dont il a besoin : la longueur de la collection, un moyen de comparer les éléments et un moyen de les échanger. Voici comment rendre une tranche de structures personnalisées triable :

type Person struct {
    Name string
    Age  int
}

type ByAge []Person

func (a ByAge) Len() int           { return len(a) }
func (a ByAge) Less(i, j int) bool { return a[i].Age < a[j].Age }
func (a ByAge) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }

func main() {
    people := []Person{
        {"Alice", 30},
        {"Bob", 25},
        {"Carol", 35},
    }
    
    sort.Sort(ByAge(people))
    fmt.Println(people)
    // [{Bob 25} {Alice 30} {Carol 35}]
}

L’idée clé consiste à créer un type nommé (ByAge) basé sur votre tranche. Cela vous permet de définir différents comportements de tri pour les mêmes données. Vous pourriez créer ByName avec une implémentation différente de Less afin de trier alphabétiquement à la place.

Une fois que votre type satisfait sort.Interface, il fonctionne automatiquement avec sort.Sort(), sort.Reverse() et sort.IsSorted().

Défi

Facile

Construisons un système d’inventaire de produits triable qui démontre la puissance de sort.Interface de Go ! Vous allez créer un type Product et implémenter plusieurs stratégies de tri, permettant de trier la même collection de différentes manières.

Vous allez organiser votre code sur deux fichiers :

product.go : définir votre type de produit et les implémentations du tri.
Créez une structure Product avec trois champs : Name (string), Price (float64) et Quantity (int).

Créez deux types nommés basés sur []Product :
- ByPrice - pour trier les produits par prix dans l’ordre croissant
- ByQuantity - pour trier les produits par quantité dans l’ordre décroissant (quantité la plus élevée en premier)
Chaque type doit implémenter les trois méthodes requises par sort.Interface : Len(), Less(i, j int) et Swap(i, j int). La méthode Less détermine l’ordre de tri pour chaque type.
main.go : construire et trier votre inventaire de produits.
Lisez un mode de tri (price ou quantity), puis lisez un nombre suivi des détails des produits. Chaque produit est fourni sur trois lignes : nom, prix et quantité.

Créez une tranche de produits, triez-les à l’aide du type de tri approprié en fonction du mode, puis affichez chaque produit dans ce format :
```
[Name]: $[Price] (x[Quantity])
```
Affichez les prix avec deux décimales.

Les entrées suivantes seront fournies :

Ligne 1 : mode de tri (price ou quantity)
Ligne 2 : nombre de produits
Lignes suivantes : détails des produits (nom, prix, quantité - trois lignes par produit)

Par exemple, étant donné :

price
3
Laptop
999.99
5
Mouse
29.99
50
Keyboard
79.99
25

Votre sortie doit être :

Mouse: $29.99 (x50)
Keyboard: $79.99 (x25)
Laptop: $999.99 (x5)

Et étant donné :

quantity
3
Laptop
999.99
5
Mouse
29.99
50
Keyboard
79.99
25

Votre sortie doit être :

Mouse: $29.99 (x50)
Keyboard: $79.99 (x25)
Laptop: $999.99 (x5)

Remarquez comment les mêmes données de produits peuvent être triées différemment en utilisant simplement un type nommé différent. Une fois que vos types satisfont à sort.Interface, ils fonctionnent parfaitement avec sort.Sort() de la bibliothèque standard.

Essayez vous-même

package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)

	// Lire le mode de tri
	var mode string
	fmt.Fscanln(reader, &mode)

	// Lire le nombre de produits
	var count int
	fmt.Fscanln(reader, &count)

	// Lire les produits
	products := make([]Product, count)
	for i := 0; i < count; i++ {
		name, _ := reader.ReadString('\n')
		name = strings.TrimSpace(name)

		priceStr, _ := reader.ReadString('\n')
		priceStr = strings.TrimSpace(priceStr)
		price, _ := strconv.ParseFloat(priceStr, 64)

		qtyStr, _ := reader.ReadString('\n')
		qtyStr = strings.TrimSpace(qtyStr)
		quantity, _ := strconv.Atoi(qtyStr)

		products[i] = Product{Name: name, Price: price, Quantity: quantity}
	}

	// TODO: Trier les produits en fonction du mode
	// Si le mode est "price", utiliser le type ByPrice
	// Si le mode est "quantity", utiliser le type ByQuantity
	// Utiliser sort.Sort() avec le type approprié

	// TODO: Afficher chaque produit au format :
	// [Name]: $[Price] (x[Quantity])
	// Utiliser fmt.Printf avec %.2f pour le formatage du prix
}