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

Estes três métodos fornecem ao algoritmo de ordenação tudo o que ele precisa: o comprimento da coleção, uma maneira de comparar elementos e uma maneira de trocá-los. Veja como tornar um slice de structs personalizadas 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 percepção é criar um tipo nomeado (ByAge) baseado no seu slice. Isso permite que você defina diferentes comportamentos de ordenação para os mesmos dados. Você poderia criar ByName com uma implementação de Less diferente para ordenar alfabeticamente em vez disso.

Assim que o seu tipo satisfizer sort.Interface, ele funcionará com sort.Sort(), sort.Reverse() e sort.IsSorted() automaticamente.

Desafio

Fácil

Vamos construir um sistema de inventário de produtos classificável que demonstra o poder da sort.Interface do Go! Você criará um tipo Product e implementará múltiplas estratégias de ordenação, permitindo que a mesma coleção seja ordenada de diferentes maneiras.

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

product.go: Defina seu tipo de produto e as implementações de ordenaçã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 ordenar produtos por preço em ordem crescente
- ByQuantity - para ordenar produtos por quantidade em ordem decrescente (maior quantidade primeiro)
Cada tipo precisa implementar os três métodos exigidos pela sort.Interface: Len(), Less(i, j int) e Swap(i, j int). O método Less determina a ordem de classificação para cada tipo.
main.go: Construa e ordene seu inventário de produtos.
Leia um modo de ordenação (price ou quantity), depois leia uma contagem seguida pelos detalhes do produto. Cada produto é fornecido em três linhas: nome, preço e quantidade.

Crie um slice de produtos, ordene-os usando o tipo de ordenação apropriado com base no modo e, em seguida, 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 ordenação (price ou quantity)
Linha 2: Número de produtos
Linhas seguintes: Detalhes do produto (nome, preço, quantidade - três linhas por produto)

Por exemplo, dado:

price
3
Laptop
999.99
5
Mouse
29.99
50
Keyboard
79.99
25

Sua saída deve ser:

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

E dado:

quantity
3
Laptop
999.99
5
Mouse
29.99
50
Keyboard
79.99
25

Sua saída deve ser:

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

Observe como os mesmos dados de produto podem ser ordenados de forma diferente simplesmente usando um tipo nomeado diferente. Uma vez que seus tipos satisfaçam a sort.Interface, eles funcionam perfeitamente com sort.Sort() da biblioteca padrão.

Folha de consulta

O pacote sort exige que os tipos implementem a sort.Interface para serem ordenáveis:

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

Para tornar um slice personalizado ordenável, crie um tipo nomeado e implemente os três métodos obrigatórios:

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

// Ordenar a coleção
sort.Sort(ByAge(people))

Você pode criar múltiplos tipos nomeados para o mesmo slice para implementar diferentes comportamentos de ordenação. Cada tipo define seu próprio método Less para determinar a ordem de classificação.

Uma vez que um tipo satisfaça a sort.Interface, ele funciona com sort.Sort(), sort.Reverse() e sort.IsSorted().

Experimente você mesmo

package main

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

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 = name[:len(name)-1] // Remover nova linha

		priceStr, _ := reader.ReadString('\n')
		priceStr = priceStr[:len(priceStr)-1]
		price, _ := strconv.ParseFloat(priceStr, 64)

		qtyStr, _ := reader.ReadString('\n')
		qtyStr = qtyStr[:len(qtyStr)-1]
		quantity, _ := strconv.Atoi(qtyStr)

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

	// TODO: Ordenar 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: Imprimir cada produto no formato:
	// [Name]: $[Price] (x[Quantity])
	// Use fmt.Printf com %.2f para formatação de preço
}