In Golang, how can I sort a list of strings alphabetically without completely ignoring case?

huangapple
go评论116阅读模式
英文:

In Golang, how can I sort a list of strings alphabetically without completely ignoring case?

问题

我希望字符串按字母顺序排序，并且可以控制是否将"A"排在"a"之前。

在Less()函数中使用strings.ToLower()无法实现这一点。有时候"A"会排在"a"之前，有时候会排在之后。

英文:

I want the strings to be sorted alphabetically with control over whether "A" comes before "a".

In the Less() function using strings.ToLower() doesn't achieve this. Sometimes "A" comes before "a", and sometimes after.

答案1

得分: 6

而不是使用strings.ToLower比较整个字符串，可以比较单个符文。

  1. type ByCase []string
  3. func (s ByCase) Len() int      { return len(s) }
  4. func (s ByCase) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
  6. func (s ByCase) Less(i, j int) bool {
  7.     iRunes := []rune(s[i])
  8.     jRunes := []rune(s[j])
  10.     max := len(iRunes)
  11.     if max > len(jRunes) {
  12.         max = len(jRunes)
  13.     }
  15.     for idx := 0; idx < max; idx++ {
  16.         ir := iRunes[idx]
  17.         jr := jRunes[idx]
  19.         lir := unicode.ToLower(ir)
  20.         ljr := unicode.ToLower(jr)
  22.         if lir != ljr {
  23.             return lir < ljr
  24.         }
  26.         // the lowercase runes are the same, so compare the original
  27.         if ir != jr {
  28.             return ir < jr
  29.         }
  30.     }
  32.     // 如果字符串在最短字符串的长度范围内相同，则较短的字符串排在前面
  33.     return len(iRunes) < len(jRunes)
  34. }

你需要翻译的内容已经翻译完毕，请确认是否满意。

英文:

instead of comparing the entire string using strings.ToLower, compare the individual runes.

https://play.golang.org/p/RUMlmrb7C3g

  1. type ByCase []string
  3. func (s ByCase) Len() int      { return len(s) }
  4. func (s ByCase) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
  6. func (s ByCase) Less(i, j int) bool {
  7. 	iRunes := []rune(s[i])
  8. 	jRunes := []rune(s[j])
  10. 	max := len(iRunes)
  11. 	if max &gt; len(jRunes) {
  12. 		max = len(jRunes)
  13. 	}
  15. 	for idx := 0; idx &lt; max; idx++ {
  16. 		ir := iRunes[idx]
  17. 		jr := jRunes[idx]
  19. 		lir := unicode.ToLower(ir)
  20. 		ljr := unicode.ToLower(jr)
  22. 		if lir != ljr {
  23. 			return lir &lt; ljr
  24. 		}
  26. 		// the lowercase runes are the same, so compare the original
  27. 		if ir != jr {
  28. 			return ir &lt; jr
  29. 		}
  30. 	}
  32.     // If the strings are the same up to the length of the shortest string, 
  33.     // the shorter string comes first
  34. 	return len(iRunes) &lt; len(jRunes)
  35. }

答案2

得分: 5

这可能是一个解决方案：

  1. package main
  3. import (
  4.     "strings"
  5.     "sort"
  6.     "fmt"
  7. )
  9. var listOfStrings []string = []string{
  10.     "mars bar",
  11.     "milk-duds",
  12.     "Mars bar",
  13.     "milk",
  14.     "milky-way",
  15.     "Milk",
  16.     "Milky-way",
  17.     "mars",
  18. }
  20. type Alphabetic []string
  22. func (list Alphabetic) Len() int { return len(list) }
  24. func (list Alphabetic) Swap(i, j int) { list[i], list[j] = list[j], list[i] }
  26. func (list Alphabetic) Less(i, j int) bool {
  27.     var si string = list[i]
  28.     var sj string = list[j]
  29.     var si_lower = strings.ToLower(si)
  30.     var sj_lower = strings.ToLower(sj)
  31.     if si_lower == sj_lower {
  32.         return si < sj
  33.     }
  34.     return si_lower < sj_lower
  35. }
  37. func main() {
  38.     fmt.Println("UNSORTED")
  39.     printStrings(listOfStrings)
  40.     sort.Sort(Alphabetic(listOfStrings))
  41.     fmt.Println()
  42.     fmt.Println("SORTED ALPHABETICALLY")
  43.     printStrings(listOfStrings)
  44. }
  46. func printStrings(slice []string) {
  47.     for i := 0; i < len(slice); i++ {
  48.         fmt.Println(slice[i])
  49.     }
  50. }

以下是输出结果：

  1. UNSORTED
  2. mars bar
  3. milk-duds
  4. Mars bar
  5. milk
  6. milky-way
  7. Milk
  8. Milky-way
  9. mars
  11. SORTED ALPHABETICALLY
  12. mars
  13. Mars bar
  14. mars bar
  15. Milk
  16. milk
  17. milk-duds
  18. Milky-way
  19. milky-way
英文:

This may be a solution:

  1. package main
  3. import (
  4.     &quot;strings&quot;
  5.     &quot;sort&quot;
  6.     &quot;fmt&quot;
  7. )
  9. var listOfStrings []string = []string{
  10.     &quot;mars bar&quot;,
  11.     &quot;milk-duds&quot;,
  12.     &quot;Mars bar&quot;,
  13.     &quot;milk&quot;,
  14.     &quot;milky-way&quot;,
  15.     &quot;Milk&quot;,
  16.     &quot;Milky-way&quot;,
  17.     &quot;mars&quot;,
  18. }
  20. type Alphabetic []string
  22. func (list Alphabetic) Len() int { return len(list) }
  24. func (list Alphabetic) Swap(i, j int) { list[i], list[j] = list[j], list[i] }
  26. func (list Alphabetic) Less(i, j int) bool {
  27.     var si string = list[i]
  28.     var sj string = list[j]
  29.     var si_lower = strings.ToLower(si)
  30.     var sj_lower = strings.ToLower(sj)
  31.     if si_lower == sj_lower {
  32.         return si &lt; sj
  33.     }
  34.     return si_lower &lt; sj_lower
  35. }
  37. func main() {
  38.     fmt.Println(&quot;UNSORTED&quot;)
  39.     printStrings(listOfStrings)
  40.     sort.Sort(Alphabetic(listOfStrings))
  41.     fmt.Println()
  42.     fmt.Println(&quot;SORTED ALPHABETICALLY&quot;)
  43.     printStrings(listOfStrings)
  44. }
  46. func printStrings(slice []string) {
  47.     for i := 0; i &lt; len(slice); i++ {
  48.         fmt.Println(slice[i])
  49.     }
  50. }

Here's the output:

  1. UNSORTED
  2. mars bar
  3. milk-duds
  4. Mars bar
  5. milk
  6. milky-way
  7. Milk
  8. Milky-way
  9. mars
  11. SORTED ALPHABETICALLY
  12. mars
  13. Mars bar
  14. mars bar
  15. Milk
  16. milk
  17. milk-duds
  18. Milky-way
  19. milky-way

答案3

得分: 1

这是一个使用strings.Map的Unicode友好方法：

  1. package main
  3. import (
  4.    "fmt"
  5.    "sort"
  6.    "strings"
  7.    "unicode"
  8. )
  10. type slice struct { sort.StringSlice }
  12. func (s slice) Less(d, e int) bool {
  13.    t := strings.Map(unicode.ToUpper, s.StringSlice[d])
  14.    u := strings.Map(unicode.ToUpper, s.StringSlice[e])
  15.    return t < u
  16. }
  18. func main() {
  19.    a := slice{
  20.       sort.StringSlice{"a", "b", "A", "B"},
  21.    }
  22.    sort.Sort(a)
  23.    fmt.Println(a.StringSlice) // [a A b B]
  24. }

https://golang.org/pkg/strings#Map

英文:

Heres a Unicode friendly method that utilizes strings.Map:

  1. package main
  3. import (
  4.    &quot;fmt&quot;
  5.    &quot;sort&quot;
  6.    &quot;strings&quot;
  7.    &quot;unicode&quot;
  8. )
  10. type slice struct { sort.StringSlice }
  12. func (s slice) Less(d, e int) bool {
  13.    t := strings.Map(unicode.ToUpper, s.StringSlice[d])
  14.    u := strings.Map(unicode.ToUpper, s.StringSlice[e])
  15.    return t &lt; u
  16. }
  18. func main() {
  19.    a := slice{
  20.       sort.StringSlice{&quot;a&quot;, &quot;b&quot;, &quot;A&quot;, &quot;B&quot;},
  21.    }
  22.    sort.Sort(a)
  23.    fmt.Println(a.StringSlice) // [a A b B]
  24. }

https://golang.org/pkg/strings#Map

huangapple
  • 本文由 发表于 2016年1月29日 10:57:12
  • 转载请务必保留本文链接：https://go.coder-hub.com/35076109.html
  • alphabetical-sort
  • go
  • sorting
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定