sort.Interface

Parte da seção Programação Orientada a Objetos do Journey de GO da Coddy. Lição 74 de 107.

O pacote sort fornece outro excelente exemplo de design baseado em interfaces. Para ordenar uma coleção personalizada, seu tipo deve implementar a sort.Interface:

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

Esses três métodos fornecem ao algoritmo de ordenação tudo de que ele precisa: o comprimento da coleção, uma forma de comparar elementos e uma forma de trocá-los. Veja como tornar um slice de structs personalizados ordenável:

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

A principal ideia é criar um tipo nomeado (ByAge) baseado na sua fatia. Isso permite definir diferentes comportamentos de ordenação para os mesmos dados. Você poderia criar ByName com uma implementação diferente de Less para ordenar alfabeticamente.

Assim que seu tipo satisfaz sort.Interface, ele funciona automaticamente com sort.Sort(), sort.Reverse() e sort.IsSorted().

Desafio

Fácil

Vamos criar um sistema de inventário de produtos classificável que demonstra o poder de sort.Interface do Go! Você criará um tipo Product e implementará várias estratégias de classificação, permitindo que a mesma coleção seja classificada de maneiras diferentes.

Você organizará seu código em dois arquivos:

product.go: Defina seu tipo de produto e as implementações de classificação.
Crie uma struct Product com três campos: Name (string), Price (float64) e Quantity (int).

Crie dois tipos nomeados baseados em []Product:
- ByPrice - para classificar os produtos por preço em ordem crescente
- ByQuantity - para classificar os produtos por quantidade em ordem decrescente (maior quantidade primeiro)
Cada tipo precisa implementar os três métodos exigidos por sort.Interface: Len(), Less(i, j int) e Swap(i, j int). O método Less determina a ordem de classificação de cada tipo.
main.go: Crie e classifique seu inventário de produtos.
Leia um modo de classificação (price ou quantity) e, em seguida, leia uma quantidade seguida pelos detalhes dos produtos. Cada produto é fornecido em três linhas: nome, preço e quantidade.

Crie um slice de produtos, classifique-o usando o tipo de classificação apropriado com base no modo e, então, imprima cada produto neste formato:
```
[Name]: $[Price] (x[Quantity])
```
Exiba os preços com duas casas decimais.

As seguintes entradas serão fornecidas:

Linha 1: Modo de classificação (price ou quantity)
Linha 2: Número de produtos
Linhas seguintes: Detalhes dos produtos (nome, preço, quantidade - três linhas por produto)

Por exemplo, considerando:

price
3
Laptop
999.99
5
Mouse
29.99
50
Keyboard
79.99
25

Sua saída deverá ser:

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

E considerando:

quantity
3
Laptop
999.99
5
Mouse
29.99
50
Keyboard
79.99
25

Sua saída deverá ser:

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

Observe como os mesmos dados de produtos podem ser classificados de maneiras diferentes simplesmente usando um tipo nomeado diferente. Depois que seus tipos satisfazem sort.Interface, eles funcionam perfeitamente com sort.Sort() da biblioteca padrão.

Experimente você mesmo

package main

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

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

	// Ler o modo de ordenação
	var mode string
	fmt.Fscanln(reader, &mode)

	// Ler o número de produtos
	var count int
	fmt.Fscanln(reader, &count)

	// Ler os produtos
	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: Ordenar os produtos com base no modo
	// Se o modo for "price", use o tipo ByPrice
	// Se o modo for "quantity", use o tipo ByQuantity
	// Use sort.Sort() com o tipo apropriado

	// TODO: Imprima cada produto no formato:
	// [Name]: $[Price] (x[Quantity])
	// Use fmt.Printf com %.2f para formatação do preço
}