Đi sắp xếp một phần của rune?

Question

Tôi gặp sự cố khi sắp xếp chuỗi theo ký tự (để kiểm tra xem hai chuỗi là đảo chữ cái, tôi muốn sắp xếp cả hai chuỗi đó và kiểm tra tính bình đẳng).

tôi có thể có được một đại diện []rune của chuỗi s như thế này:

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

Và tôi có thể sắp xếp ints như thế này

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

Nhưng rune chỉ là một bí danh cho int32 vì vậy tôi nên có thể gọi

sort.Ints(runes) 

Tuy nhiên, tôi gặp lỗi:

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

Vậy ... làm cách nào để sắp xếp một phần int32, int64 hoặc int *?

EDIT: Tôi đã nhận được rune của tôi được sắp xếp, nhưng cậu bé, điều này là xấu xí.

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

Vì vậy, về cơ bản nếu bạn có một lát bất kỳ thứ gì, bạn sẽ phải gói nó theo kiểu thực hiện sort.Interface. Tất cả những triển khai đó sẽ có cùng các đối tượng phương thức giống hệt nhau (như sort.IntSlice và sort.Float64Slice). Nếu điều này thực sự xấu xí như thế nào thì tại sao họ không cung cấp các trình bao bọc WhateverSlice này trong gói sort? Việc thiếu generics bắt đầu làm tổn thương rất nặng nề. Phải có cách phân loại tốt hơn.

Answer 1

Sử dụng sort.Sort(data Interface) và triển khai sort.Interface, xem ví dụ về tài liệu gói.

Bạn không thể sử dụng rune là int32 là int. Kiểm tra comment của 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

Giống như một điểm so sánh, đây là những gì mọi thứ có thể trông như thế nào nếu giao diện sắp xếp hơi khác. Tức là, thay vì giao diện nằm trên vùng chứa , thì mọi thứ sẽ trông như thế nào nếu giao diện ở trên các yếu tố thay thế?

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

Ở đây, chúng ta định nghĩa một giao diện Comparable, và chúng tôi nhận loại của chúng tôi ComparableRune để thỏa mãn nó. Nhưng vì nó là một giao diện, chúng ta phải làm như đấm bốc vụng về để đi rune-ComparableRune để cử động có thể đá trong:

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

và unboxing để lấy lại rune của chúng tôi:

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

Cách tiếp cận này dường như yêu cầu chúng tôi biết cách thực hiện các kiểu nhập để chuyển qua lại giữa giao diện và loại động của giá trị. Có vẻ như chúng ta sẽ cần sử dụng nhiều phần của Go --- cơ học hơn --- so với cách tiếp cận sử dụng container làm giao diện.

Answer 3

Có, trên thực tế, cách mềm chung để thực hiện những gì bạn muốn.

Kiểm tra các gói sau:

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

đặc biệt là các tập tin sau đây:

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

Ví dụ về cách nó được sử dụng:

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

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

Có rất nhiều niềm vui thú vị khác các thuật toán chung được thực hiện thông qua sự phản chiếu trong gói đó.

Tất cả tín dụng đi đến @BurntSushi.

Answer 4

Lưu ý: Đi 1.8 sẽ giới thiệu người trợ giúp để phân loại lát.
Xem và commit 22a2bdf bởi 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] 
    }) 
}