8wDlpd.png
8wDFp9.png
8wDEOx.png
8wDMfH.png
8wDKte.png

golang 中是否有一个针对 int 参数片段或可变数量的 int 参数的内置 min 函数?

As3adTintin 2月前

61 0

是否有一个内置函数可以返回 int 参数切片的最小值:func MinIntSlice(v []int) (m int) { if len(v) > 0 { m = v[0] } for i := 1; i < len(v); i...

是否有一个内置函数可以返回 int 参数片段的最小值:

func MinIntSlice(v []int) (m int) {
    if len(v) > 0 {
        m = v[0]
    }
    for i := 1; i < len(v); i++ {
        if v[i] < m {
            m = v[i]
        }
    }
    return
}

或可变数量的 int 参数的最小值:

func MinIntVarible(v1 int, vn ...int) (m int) {
    m = v1
    for i := 0; i < len(vn); i++ {
        if vn[i] < m {
            m = vn[i]
        }
    }
    return
}

如果没有,最好的“约定”是否只是创建一个包含这样的帮助程序的包?

帖子版权声明 1、本帖标题:golang 中是否有一个针对 int 参数片段或可变数量的 int 参数的内置 min 函数?
    本站网址:http://xjnalaquan.com/
2、本网站的资源部分来源于网络,如有侵权,请联系站长进行删除处理。
3、会员发帖仅代表会员个人观点,并不代表本站赞同其观点和对其真实性负责。
4、本站一律禁止以任何方式发布或转载任何违法的相关信息,访客发现请向站长举报
5、站长邮箱:yeweds@126.com 除非注明,本帖由As3adTintin在本站《go》版块原创发布, 转载请注明出处!
最新回复 (0)
  • 编辑:这个答案已经过时了。从 1.21 开始,Go 中现在有内置函数 min 和 max。请参阅 Jonas 的回答。

    没有内置此功能。

    如果您仅在一个包中需要此功能,则可以编写一个未导出的函数(例如 minIntSlice )。

    如果您需要在多个包中使用此功能,则可以创建一个包并将类似的功能放入其中。您应该考虑将此包设为内部包( https://golang.org/s/go14internal )。

    关于如何改进代码的一些建议:

    1. p5

    2. p6

       for i, e := range v {     if i==0 || e < m {         m = e     } }

    如果不给出值的索引,它将为您提供最小值 0,这可能不存在于给定的值中,因此您还必须对索引应用条件。

  • 感谢您提供指向“内部”包的指针。我确实有类似的未导出的重复函数,而内部看起来是更好地维护这些函数的方法。

  • 这个答案已经过时了。从 1.21 开始,Go 中现在有内置函数 min 和 max。请参阅 Jonas 的答案。

  • 从 Go 开始, 1.21 现在有内置函数来获取 max min ,以及一个新的 slices 包来实现切片的相同功能。

    https://go.dev/ref/spec#Min_and_max

    min(2, -5, 8, 1.2) // Result: -5
    max(2, -5, 8, 1.2) // Result: 8
    

    对于切片,请使用以下 slices 包: https://pkg.go.dev/slices

    import "slices"
    
    x := []float64{2, -5, 8, 1.2}
    slices.Min(x) // Result: -5
    slices.Max(x) // Result: 8
    
  • 正如@kostya正确指出的那样,Golang中没有内置的最小值或最大值函数。

    不过,我建议一个稍微不同的解决方案:

    func MinMax(array []int) (int, int) {
        var max int = array[0]
        var min int = array[0]
        for _, value := range array {
            if max < value {
                max = value
            }
            if min > value {
                min = value
            }
        }
        return min, max
    }
    

    这样就解决了空切片的问题:出现运行时错误( index out of range )并且最大值是免费的。:-)

  •     min := s[0]
        for i :=1; i < len(s); i++ {
            if min > s[i] {
                min = s[i]
            }
        }
    

    min > s[i]? min = s[i] : min

  • 请不要只发布代码作为答案,还应解释您的代码的作用以及它如何解决问题。带有解释的答案通常更有帮助且质量更高,也更有可能吸引点赞。

  • 如果你不关心输入数组

    import . "sort"
    func MinIntSlice(v []int){
        Ints(v)
        return z[0]
    }
    
    func MaxIntSlice(v []int){
        Ints(v)
        return z[len(v)-1]
    }
    // and MinMax version
    func MinMax(v []int)(int,int){
        Ints(v)
        return z[0],z[len(v)-1]
    }
    
  • 此包 用于单独值或切片的 Min 实现 Max go get 可以像这样使用:

    import (
        "fmt"
        "<Full URL>/go-imath/ix" // Functions for int type
    )
    ...
    fmt.Println(ix.Min(100, 152)) // Output: 100
    fmt.Println(ix.Mins(234, 55, 180)) // Output: 55
    fmt.Println(ix.MinSlice([]int{2, 29, 8, -1})) // Output: -1
    
  • 标准包中没有此类操作的函数。

    但是, gonum 库 提供了函数 floats.Min(x) floats.Max(x) (以及其他用于处理数值数据的有趣函数)。

    用法:

    package main
    
    import (
        "fmt"
        "gonum.org/v1/gonum/floats"
    )
    
    func main() {
        x := []float64{1, 6, 9, -3, -5}
        minX := floats.Min(x)
        maxX := floats.Max(x)
        fmt.Printf("Min: %f, max %f\n", minX, maxX)
    }
    

    结果:

    Min: -5.000000, max 9.000000
    
  • 对于包含数百万个项目的巨大切片(例如 25 万像素的图像 []int ),你可以通过分块计算最小值/最大值来获得显著的性能提升:

    func GetMinMax(data []int) (int, int) {
        minVal := data[0]
        maxVal := data[0]
        for i := range data {
            if data[i] < minVal {
                minVal = data[i]
            }
    
            if data[i] > maxVal {
                maxVal = data[i]
            }
        }
    
        return minVal, maxVal
    }
    
    func GetMinMaxConcurrent(data []int) (int, int) {
        numChan := make(chan int)
    
        numChunks := runtime.NumCPU()
        chunkSize := len(data) / numChunks
    
        // Process
        var wg sync.WaitGroup
        for i := 0; i < numChunks; i++ {
            wg.Add(1)
            go func(i, chunkSize int, numChan chan int) {
                startIndex := i * chunkSize
                endIndex := startIndex + chunkSize
                if endIndex > len(data) {
                    endIndex = len(data)
                }
    
                minVal, maxVal := GetMinMax(data[startIndex:endIndex])
                numChan <- minVal
                numChan <- maxVal
                wg.Done()
            }(i, chunkSize, numChan)
        }
    
        // Collect results
        resultsChan := make(chan int)
        defer close(resultsChan)
    
        go func(numChan, resultsChan chan int) {
            arr := make([]int, 0)
            for num := range numChan {
                arr = append(arr, num)
            }
            minVal, maxVal := GetMinMax(arr)
            resultsChan <- minVal
            resultsChan <- maxVal
        }(numChan, resultsChan)
    
        wg.Wait()
        close(numChan) // needed so results routine can return
    
        return <-resultsChan, <-resultsChan
    }
    

    此代码不适用于小切片,仅当您的切片足够大以便能够从同时处理块中受益时才使用。

  • DVT 2月前 0 只看Ta
    引用 13

    通过排序,它可以更短:

    func MinIntSlice(v []int) int {
      sort.Ints(v)
      return v[0]
    }
    
    func MaxIntSlice(v []int) int {
      sort.Ints(v)
      return v[len(v)-1]
    }
    

    但不要忘记根据您的喜好对其进行修改以获得零长度切片。

  • 仅仅为了挑选一些东西而改变底层切片是一个糟糕的想法。这可能会改变其他地方隐式排序的断言

  • 排序是o(n log n)但最大值是线性时间o(n)算法,这个“代码更短”但算法更差。

  • mysl 2月前 0 只看Ta
    引用 16

    是的,这远非最佳。但是当你需要在算法中间的某个地方对小切片进行最小/最大操作时,可以对其进行排序并取第一个/最后一个,而不是创建你永远不会再使用的单独函数。

  • 使用@kostya的 答案

    1. p1

      for i, e := range v {    if i==0 || e < m {        m = e    }}

    如果不给出值的索引,它将给出最小值 0,这可能不存在于给定的值中

返回
作者最近主题: