去整理一片符文？

Question

我很难按字符对字符串进行排序(为了检查两个字符串是否是字谜，我希望对它们进行排序，并检查是否相等)。

我可以得到字符串s的如下所示的s表示：

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

我可以像这样分类

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

但是rune只是int32的别名，所以我应该可以调用

sort.Ints(runes) 

但是，我得到了错误：

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

所以..。如何对int32、int64或int*进行排序？

编辑：我确实把我的符文整理好了，但是孩子，这太丑了。

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

因此，基本上，如果您有任何东西的一部分，就必须将其包装成实现sort.Interface的类型。所有这些实现都将具有完全相同的方法主体(如sort.IntSlice和sort.Float64Slice)。如果这真的很难看，那他们为什么不在WhateverSlice包中提供这些sort包装呢？仿制药的缺乏现在开始造成很大的伤害。一定有更好的分类方法。

Answer 1

使用sort.Sort(data Interface)并实现sort.Interface，请参阅包文档上的示例。

您不能使用rune，即int32作为int。检查评论 of int。

int是至少32位大小的带符号整数类型。但是，它是一个不同的类型，而不是int32的别名。

Answer 2

注意: Go 1.8将引入用于排序片的帮助程序。

见第16721期和提交22a2bdf ( 布拉德·菲茨帕特里克 )

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

Answer 3

作为一个比较点，如果排序接口稍有不同的话，下面的情况可能是什么样子。也就是说，如果接口是在元素上，而不是容器上的接口，情况会是怎样的呢？

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

在这里，我们定义了一个Comparable接口，并得到了我们的类型ComparableRune来满足它。但是，因为它是一个接口，所以我们必须进行从rune到ComparableRune的笨拙装箱，这样动态调度就可以启动：

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

为了拿回我们的符文：

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

这种方法似乎要求我们知道如何在接口和值的动态类型之间来回进行类型转换。似乎我们需要使用更多的Go部件--更多的机械装置--而不是使用容器作为接口的方法。