分割版本字符串直到找到为止

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

splitting version string until found

问题

在这个问题中，你想要实现以下输出：

  1. Version 3.14.15.5.123.2 is called: apple
  2. Version 3.14.15.13.123 is called: orange
  3. Version 3.14.15.19.12 is called: pear

你在考虑使用字符串搜索、切片、搜索、切片循环的方式来找到匹配的结果。你想知道是否有更简单的方法。

以下是一个可能的解决方案：

  1. package main
  3. import (
  4. 	"fmt"
  5. )
  7. type apps []app
  9. type app struct {
  10. 	version string
  11. }
  13. type releases []release
  15. type release struct {
  16. 	name     string
  17. 	platform string
  18. }
  20. func main() {
  22. 	var versions releases
  23. 	versions = append(versions, release{name: "apple", platform: "3.14.15"})
  24. 	versions = append(versions, release{name: "orange", platform: "3.14.15.13"})
  25. 	versions = append(versions, release{name: "pear", platform: "3.14.19"})
  27. 	var test apps
  28. 	test = append(test, app{version: "3.14.15.5.123.2"}) // should map to apple
  29. 	test = append(test, app{version: "3.14.15.13.123"})  // should map to orange
  30. 	test = append(test, app{version: "3.14.15.19.12"})   // should map to pear
  32. 	for _, r := range test {
  33. 		for _, v := range versions {
  34. 			if v.platform == r.version {
  35. 				fmt.Printf("Version %s is called: %s\n", r.version, v.name)
  36. 				break
  37. 			}
  38. 		}
  39. 	}
  41. }

这段代码使用了两个结构体类型：app 和 release。app 结构体表示应用程序的版本，release 结构体表示发布的版本。我们首先定义了一个 versions 切片，其中包含了所有的发布版本。然后，我们定义了一个 test 切片，其中包含了要测试的应用程序版本。

接下来，我们使用嵌套的循环来比较每个测试版本和发布版本，如果找到匹配的版本，就输出对应的应用程序名称。

希望这可以帮助到你！

英文:

Sort of went down the rabbit hole on this one:

  1. package main
  3. import (
  4. 	"fmt"
  5. )
  7. type apps []app
  9. type app struct {
  10. 	version string
  11. }
  13. type releases []release
  15. type release struct {
  16. 	name     string
  17. 	platform string
  18. }
  20. func main() {
  22. 	var versions releases
  23. 	versions = append(versions, release{name: "apple", platform: "3.14.15"})
  24. 	versions = append(versions, release{name: "orange", platform: "3.14.15.13"})
  25. 	versions = append(versions, release{name: "pear", platform: "3.14.19"})
  27. 	var test apps
  28. 	test = append(test, app{version: "3.14.15.5.123.2"}) // should map to apple
  29. 	test = append(test, app{version: "3.14.15.13.123"})  // should map to orange
  30. 	test = append(test, app{version: "3.14.15.19.12"})   // should map to pear
  32. 	for _, r := range test {
  33. 		fmt.Printf("Version %s is called: %s\n", r.version, "?")
  34. 	}
  36. }

I'm trying to achieve the following output:

  1. Version 3.14.15.5.123.2 is called: apple
  2. Version 3.14.15.13.123 is called: orange
  3. Version 3.14.15.19.12 is called: pear

I was thinking some sort of string search, slice, search, slice loop until i could find a match? is there an easier way?

答案1

得分: 3

你需要找到发布类型中最长的前缀。为此，你可以实现一个类似下面这样的函数：

  1. package main
  3. import (
  4. 	"fmt"
  5. 	"strings"
  6. )
  8. type apps []app
  10. type app struct {
  11. 	version string
  12. }
  14. type releases []release
  16. type release struct {
  17. 	name     string
  18. 	platform string
  19. }
  21. func (r releases) FindName(version string) string {
  22. 	result := ""
  23. 	max := 0
  24. 	for _, release := range r {
  25. 		if strings.HasPrefix(version, release.platform) {
  26. 			if max < len(release.platform) {
  27. 				max = len(release.platform)
  28. 				result = release.name
  29. 			}
  30. 		}
  31. 	}
  32. 	return result
  33. }
  35. func main() {
  37. 	var versions releases
  38. 	versions = append(versions, release{name: "apple", platform: "3.14.15"})
  39. 	versions = append(versions, release{name: "orange", platform: "3.14.15.13"})
  40. 	versions = append(versions, release{name: "pear", platform: "3.14.19"})
  42. 	var test apps
  43. 	test = append(test, app{version: "3.14.15.5.123.2"}) // 应该映射到 apple
  44. 	test = append(test, app{version: "3.14.15.13.123"})  // 应该映射到 orange
  45. 	test = append(test, app{version: "3.14.19.12"})      // 应该映射到 pear
  47. 	for _, r := range test {
  48. 		fmt.Printf("版本 %s 被称为：%s\n", r.version, versions.FindName(r.version))
  49. 	}
  51. }
英文:

You have to find the longest prefix in the releases type. For this you can implement a func like this one:

  1. package main
  3. import (
  4. 	&quot;fmt&quot;
  5. 	&quot;strings&quot;
  6. )
  8. type apps []app
  10. type app struct {
  11. 	version string
  12. }
  14. type releases []release
  16. type release struct {
  17. 	name     string
  18. 	platform string
  19. }
  21. func (r releases) FindName(version string) string {
  22. 	result := &quot;&quot;
  23. 	max := 0
  24. 	for _, release := range r {
  25. 		if strings.HasPrefix(version, release.platform) {
  26. 			if max &lt; len(release.platform) {
  27. 				max = len(release.platform)
  28. 				result = release.name
  29. 			}
  30. 		}
  31. 	}
  32. 	return result
  33. }
  35. func main() {
  37. 	var versions releases
  38. 	versions = append(versions, release{name: &quot;apple&quot;, platform: &quot;3.14.15&quot;})
  39. 	versions = append(versions, release{name: &quot;orange&quot;, platform: &quot;3.14.15.13&quot;})
  40. 	versions = append(versions, release{name: &quot;pear&quot;, platform: &quot;3.14.19&quot;})
  42. 	var test apps
  43. 	test = append(test, app{version: &quot;3.14.15.5.123.2&quot;}) // should map to apple
  44. 	test = append(test, app{version: &quot;3.14.15.13.123&quot;})  // should map to orange
  45. 	test = append(test, app{version: &quot;3.14.19.12&quot;})      // should map to pear
  47. 	for _, r := range test {
  48. 		fmt.Printf(&quot;Version %s is called: %s\n&quot;, r.version, versions.FindName(r.version))
  49. 	}
  51. }

答案2

得分: 1

如果你需要进行多次查找，那么你可以构建一个索引并在其中进行搜索。这样，搜索的最大时间复杂度将是 O(n)，其中 n 是你要搜索的版本号的长度。

  1. package main
  3. import (
  4. 	"fmt"
  5. 	"sort"
  6. 	"strings"
  7. )
  9. type apps []app
  11. type app struct {
  12. 	version string
  13. }
  15. type releases []release
  17. type release struct {
  18. 	name     string
  19. 	platform string
  20. }
  22. var index map[string]string
  24. func BuildIndex(r releases) {
  25. 	sort.Slice(r, func(i, j int) bool { return r[i].platform < r[j].platform })
  26. 	index = make(map[string]string)
  27. 	for _, release := range r {
  28. 		s := ""
  29. 		for _, rn := range release.platform {
  30. 			s += string(rn)
  31. 			if strings.HasSuffix(s, ".") {
  32. 				continue
  33. 			}
  34. 			if _, found := index[s]; !found {
  35. 				index[s] = release.name
  36. 			}
  37. 		}
  38. 	}
  39. }
  41. func FindInIndex(v string) string {
  42. 	for {
  43. 		if name, found := index[v]; found {
  44. 			return name
  45. 		}
  46. 		v = v[:len(v)-1]
  47. 		if v == "" {
  48. 			break
  49. 		}
  50. 	}
  51. 	return ""
  52. }
  54. func main() {
  55. 	var versions releases
  56. 	versions = append(versions, release{name: "apple", platform: "3.14.15"})
  57. 	versions = append(versions, release{name: "orange", platform: "3.14.15.13"})
  58. 	versions = append(versions, release{name: "pear", platform: "3.14.19"})
  60. 	BuildIndex(versions)
  62. 	var test apps
  63. 	test = append(test, app{version: "3.14.15.5.123.2"}) // should map to apple
  64. 	test = append(test, app{version: "3.14.15.13.123"})  // should map to orange
  65. 	test = append(test, app{version: "3.14.19.12"})      // should map to pear
  67. 	for _, r := range test {
  68. 		fmt.Printf("Version %s is called: %s\n", r.version, FindInIndex(r.version))
  69. 	}
  71. }

以上是要翻译的代码部分。

英文:

If you need to make so many lookups, then you can build an index and search in it. This way a search would take optimally maximum O(n) where n is the length of the version you are searching.

  1. package main
  2. import (
  3. &quot;fmt&quot;
  4. &quot;sort&quot;
  5. &quot;strings&quot;
  6. )
  7. type apps []app
  8. type app struct {
  9. version string
  10. }
  11. type releases []release
  12. type release struct {
  13. name     string
  14. platform string
  15. }
  16. var index map[string]string
  17. func BuildIndex(r releases) {
  18. sort.Slice(r, func(i, j int) bool { return r[i].platform &lt; r[j].platform })
  19. index = make(map[string]string)
  20. for _, release := range r {
  21. s := &quot;&quot;
  22. for _, rn := range release.platform {
  23. s += string(rn)
  24. if strings.HasSuffix(s, &quot;.&quot;) {
  25. continue
  26. }
  27. if _, found := index
    展开收缩
    ; !found {
  28. index
    展开收缩
     = release.name
  29. }
  30. }
  31. }
  32. }
  33. func FindInIndex(v string) string {
  34. for {
  35. if name, found := index[v]; found {
  36. return name
  37. }
  38. v = v[:len(v)-1]
  39. if v == &quot;&quot; {
  40. break
  41. }
  42. }
  43. return &quot;&quot;
  44. }
  45. func main() {
  46. var versions releases
  47. versions = append(versions, release{name: &quot;apple&quot;, platform: &quot;3.14.15&quot;})
  48. versions = append(versions, release{name: &quot;orange&quot;, platform: &quot;3.14.15.13&quot;})
  49. versions = append(versions, release{name: &quot;pear&quot;, platform: &quot;3.14.19&quot;})
  50. BuildIndex(versions)
  51. var test apps
  52. test = append(test, app{version: &quot;3.14.15.5.123.2&quot;}) // should map to apple
  53. test = append(test, app{version: &quot;3.14.15.13.123&quot;})  // should map to orange
  54. test = append(test, app{version: &quot;3.14.19.12&quot;})      // should map to pear
  55. for _, r := range test {
  56. fmt.Printf(&quot;Version %s is called: %s\n&quot;, r.version, FindInIndex(r.version))
  57. }
  58. }

huangapple
  • 本文由 发表于 2021年9月3日 04:06:26
  • 转载请务必保留本文链接：https://go.coder-hub.com/69036439.html
  • go
匿名

发表评论

匿名网友

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

确定