Étant donné ce bloc de code
map[string]int {"hello":10, "foo":20, "bar":20}
Je voudrais imprimer
foo, 20
bar, 20
hello, 10
Dans l'ordre du plus haut au plus bas
Étant donné ce bloc de code
map[string]int {"hello":10, "foo":20, "bar":20}
Je voudrais imprimer
foo, 20
bar, 20
hello, 10
Dans l'ordre du plus haut au plus bas
Trouvé la réponse sur Golang-nuts par Andrew Gerrand
Vous pouvez implémenter l'interface de tri en écrivant les fonctions len/less/swap.
func rankByWordCount(wordFrequencies map[string]int) PairList{
pl := make(PairList, len(wordFrequencies))
i := 0
for k, v := range wordFrequencies {
pl[i] = Pair{k, v}
i++
}
sort.Sort(sort.Reverse(pl))
return pl
}
type Pair struct {
Key string
Value int
}
type PairList []Pair
func (p PairList) Len() int { return len(p) }
func (p PairList) Less(i, j int) bool { return p[i].Value < p[j].Value }
func (p PairList) Swap(i, j int){ p[i], p[j] = p[j], p[i] }
Pour le post original, veuillez le trouver ici https://groups.google.com/forum/#!topic/golang-nuts/FT7cjmcL7gw
Il y a une nouvelle fonction sort.Slice dans go 1.8, donc maintenant c'est plus simple.
package main
import (
"fmt"
"sort"
)
func main() {
m := map[string]int{
"something": 10,
"yo": 20,
"blah": 20,
}
type kv struct {
Key string
Value int
}
var ss []kv
for k, v := range m {
ss = append(ss, kv{k, v})
}
sort.Slice(ss, func(i, j int) bool {
return ss[i].Value > ss[j].Value
})
for _, kv := range ss {
fmt.Printf("%s, %d\n", kv.Key, kv.Value)
}
}
Par exemple :
package main
import (
"fmt"
"sort"
)
func main() {
m := map[string]int{"hello": 10, "foo": 20, "bar": 20}
n := map[int][]string{}
var a []int
for k, v := range m {
n[v] = append(n[v], k)
}
for k := range n {
a = append(a, k)
}
sort.Sort(sort.Reverse(sort.IntSlice(a)))
for _, k := range a {
for _, s := range n[k] {
fmt.Printf("%s, %d\n", s, k)
}
}
}
Sortie :
foo, 20
bar, 20
hello, 10
Trier les clés d'abord par valeur et ensuite itérer la carte :
package main
import (
"fmt"
"sort"
)
func main() {
counts := map[string]int{"hello": 10, "foo": 20, "bar": 20}
keys := make([]string, 0, len(counts))
for key := range counts {
keys = append(keys, key)
}
sort.Slice(keys, func(i, j int) bool { return counts[keys[i]] > counts[keys[j]] })
for _, key := range keys {
fmt.Printf("%s, %d\n", key, counts[key])
}
}
J'ai souvent besoin de trier un map[string]int
de quelque chose que je compte et j'ai utilisé ce qui suit.
func rankMapStringInt(values map[string]int) []string {
type kv struct {
Key string
Value int
}
var ss []kv
for k, v := range values {
ss = append(ss, kv{k, v})
}
sort.Slice(ss, func(i, j int) bool {
return ss[i].Value > ss[j].Value
})
ranked := make([]string, len(values))
for i, kv := range ss {
ranked[i] = kv.Key
}
return ranked
}
Utilisez-le pour itérer sur les clés dans l'ordre des valeurs.
values := map[string]int{"foo": 10, "bar": 20, "baz": 1}
for i, index := range rankMapStringInt(values) {
fmt.Printf("%3d: %s -> %d", i, index, values[index])
}
Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.