Czy sortujesz kawałki run?

Question

Mam problem z sortowaniem ciągów znaków według znaków (aby sprawdzić, czy dwa ciągi są anagramami, chcę je posortować i sprawdzić równość).

mogę uzyskać []rune reprezentację ciąg s tak:

runes := make([]rune, len(s)) 
copy(runes, []rune(s)) 

I mogę posortować ints jak to

someInts := []int{5, 2, 6, 3, 1, 4} // unsorted 
sort.Ints(someInts) 

Ale rune tylko aliasem int32 więc powinienem być można zadzwonić pod numer

sort.Ints(runes) 

Jednakże pojawia się błąd:

cannot use runes (type []rune) as type []int in function argument 

Więc ... Jak sortować plasterek Int32, Int64 lub int *?

EDIT: Zrobiłem moje runy posortowane, ale chłopcze, to jest brzydkie.

type RuneSlice []rune 

func (p RuneSlice) Len() int   { return len(p) } 
func (p RuneSlice) Less(i, j int) bool { return p[i] < p[j] } 
func (p RuneSlice) Swap(i, j int)  { p[i], p[j] = p[j], p[i] } 

func sorted(s string) string { 
    runes := []rune(s) 
    sort.Sort(RuneSlice(runes)) 
    return string(runes) 
} 

Więc w zasadzie, jeśli masz kawałek cokolwiek, trzeba zawinąć go w typie, który implementuje sort.Interface. Wszystkie te implementacje będą miały dokładnie takie same ciała metod (jak sort.IntSlice i sort.Float64Slice). Jeśli tak naprawdę to musi być brzydkie, dlaczego nie dostarczyły one owijaczy WhateverSlice w pakiecie sort? Brak leków generycznych zaczyna teraz bardzo mocno boleć. Musi istnieć lepszy sposób sortowania rzeczy.

Answer 1

Użyj sort.Sort(data Interface) i zaimplementuj sort.Interface, zobacz przykłady na dokumentacji pakietu.

Nie można użyć rune, który jest int32 jako int. Sprawdź comment z int.

int is a signed integer type that is at least 32 bits in size. It is a distinct type, however, and not an alias for, say, int32.

Answer 2

Oto, co może wyglądać, jeśli interfejs sortowania był nieco inny. To znaczy, zamiast interfejsu znajdującego się na pojemniku , co by wyglądało, gdyby interfejs był zamiast tego na elementach ?

package main 

import (
    "fmt" 
    "sort" 
) 

type Comparable interface { 
    LessThan(Comparable) bool 
} 

type ComparableSlice []Comparable 

func (c ComparableSlice) Len() int { 
    return len(c) 
} 

func (c ComparableSlice) Less(i, j int) bool { 
    return c[i].LessThan(c[j]) 
} 

func (c ComparableSlice) Swap(i, j int) { 
    c[i], c[j] = c[j], c[i] 
} 

func SortComparables(elts []Comparable) { 
    sort.Sort(ComparableSlice(elts)) 
} 

////////////////////////////////////////////////////////////////////// 
// Let's try using this: 

type ComparableRune rune 

func (r1 ComparableRune) LessThan(o Comparable) bool { 
    return r1 < o.(ComparableRune) 
} 

func main() { 
    msg := "Hello world!" 

    comparables := make(ComparableSlice, len(msg)) 
    for i, v := range msg { 
     comparables[i] = ComparableRune(v) 
    } 

    SortComparables(comparables) 

    sortedRunes := make([]rune, len(msg)) 
    for i, v := range comparables { 
     sortedRunes[i] = rune(v.(ComparableRune)) 
    } 

    fmt.Printf("result: %#v\n", string(sortedRunes)) 
} 

Tutaj definiujemy interfejs Comparable, a my dostajemy nasz typ ComparableRune by go zadowolić. Ale ponieważ jest to interfejs, musimy zrobić niezręczną boks jechać z rune do ComparableRune tak że dynamiczny wysyłka może kopać w:

comparables := make(ComparableSlice, len(msg)) 
    for i, v := range msg { 
     comparables[i] = ComparableRune(v) 
    } 

i unboxing wrócić nasze runy:

sortedRunes := make([]rune, len(msg)) 
    for i, v := range comparables { 
     sortedRunes[i] = rune(v.(ComparableRune)) 
    } 

To podejście wydaje się wymagać od nas umiejętności wykonywania typowań danych w celu przechodzenia między interfejsem a dynamicznym typem wartości. Wygląda na to, że potrzebowalibyśmy więcej części Go --- więcej mechaniki --- niż podejście, które wykorzystuje kontener jako interfejs.

Answer 3

Istnieje, w pewnym sensie, miękki generyczny sposób robienia tego, co chcesz.

Sprawdź następujący pakiet:

https://github.com/BurntSushi/ty/tree/master/fun

zwłaszcza następujący plik:

https://github.com/BurntSushi/ty/blob/master/fun/sort_test.go

Przykład tego, jak jest on używany:

tosort := []int{10, 3, 5, 1, 15, 6} 

fun.Sort(func(a, b int) bool { 
    return b < a 
}, tosort) 

Istnieje wiele innych ciekawych zabawy ogólne algorytmy zaimplementowane poprzez odbicie w tym pakiecie.

Wszystkie kredyty idą do @BurntSushi.

Answer 4

Uwaga: Przejdź 1.8, aby wprowadzić pomocników do sortowania plasterków.
Zobacz i commit 22a2bdf przez Brad Fitzpatrick

var strings = [...]string{"", "Hello", "foo", "bar", "foo", "f00", "%*&^*&^&", "***"} 

func TestSlice(t *testing.T) { 
    data := strings 
    Slice(data[:], func(i, j int) bool { 
     return data[i] < data[j] 
    }) 
}