在Go中找到两个整数之间的最小值的正确方法是什么？

我在我的程序中导入了数学库，我试图通过以下方式找到三个数字中的最小值：

v1[j+1]=math.Min（v1[j]+1，math.Min（v0[j+1]+1，v0[j]+成本））

其中v1声明为：

t := "stackoverflow"
v1 := make([]int, len(t)+1)

但是，当我运行我的程序时，我得到以下错误：

./levenshtein_distance.go:36: cannot use int(v0[j + 1] + 1) (type int) as type float64 in argument to math.Min

./levenshtein_distance.go:36: cannot use math.Min(int(v1[j] + 1), math.Min(int(v0[j + 1] + 1), int(v0[j] + cost))) (type float64) as type int in assignment

我觉得这很奇怪，因为我还有另外一个我写的程序

fmt.Println（数学最小值（2,3））

该程序输出

2

，没有任何抱怨

因此，我最终将这些值转换为float64，以便

math.Min

可以工作：

v1[j+1] = math.Min(float64(v1[j]+1), math.Min(float64(v0[j+1]+1), float64(v0[j]+cost)))

通过这种方法，我得到了以下错误：

./levenshtein_distance.go:36: cannot use int(v0[j + 1] + 1) (type int) as type float64 in argument to math.Min

./levenshtein_distance.go:36: cannot use math.Min(int(v1[j] + 1), math.Min(int(v0[j + 1] + 1), int(v0[j] + cost))) (type float64) as type int in assignment

所以为了解决这个问题，我只是将结果转换回

int

我认为这是非常低效和难以阅读的：

v1[j+1] = int(math.Min(float64(v1[j]+1), math.Min(float64(v0[j+1]+1), float64(v0[j]+cost))))

我还编写了一个小的

minInt

函数，但我认为这应该是不必要的，因为其他使用

math.Min

的程序在获取整数时工作得很好，所以我得出结论，这一定是我的程序的问题，而不是库本身的问题

有什么是我做错的吗

下面是一个程序，您可以使用它来重现上述问题，具体来说是第36行： 包干管

import (
    "math"
)

func main() {
    LevenshteinDistance("stackoverflow", "stackexchange")
}

func LevenshteinDistance(s string, t string) int {
    if s == t {
        return 0
    }
    if len(s) == 0 {
        return len(t)
    }
    if len(t) == 0 {
        return len(s)
    }

    v0 := make([]int, len(t)+1)
    v1 := make([]int, len(t)+1)

    for i := 0; i < len(v0); i++ {
        v0[i] = i
    }

    for i := 0; i < len(s); i++ {
        v1[0] = i + 1
        for j := 0; j < len(t); j++ {
            cost := 0
            if s[i] != t[j] {
                cost = 1
            }
            v1[j+1] = int(math.Min(float64(v1[j]+1), math.Min(float64(v0[j+1]+1), float64(v0[j]+cost))))
        }

        for j := 0; j < len(v0); j++ {
            v0[j] = v1[j]
        }
    }
    return v1[len(t)]
}

导入(
“数学”
)
func main（）{
LevenshteInstance（“stackoverflow”、“stackexchange”）
}
func levenshteindication（s字符串，t字符串）int{
如果s==t{
返回0
}
如果len=0{
回程透镜（t）
}
如果len（t）==0{
返回透镜（s）
}
v0:=制造（[]整数，长度（t）+1）
v1:=make（[]整数，len（t）+1）
对于i:=0；i

例如

package main

import "fmt"

func min(x, y int) int {
    if x < y {
        return x
    }
    return y
}

func main() {
    t := "stackoverflow"
    v0 := make([]int, len(t)+1)
    v1 := make([]int, len(t)+1)
    cost := 1
    j := 0

    v1[j+1] = min(v1[j]+1, min(v0[j+1]+1, v0[j]+cost))

    fmt.Println(v1[j+1])
}

主程序包
输入“fmt”
func min（x，y int）int{
如果x

输出：

1 1.

---

不，我认为写这样的东西很好：例如，它是否靠近文件的顶部：

func min(a, b int) int {
    if a < b {
        return a
    }
    return b
}

func min（a，b int）int{
如果a

---

math.Min（2,3）

碰巧工作是因为。不过，请注意，通常不要将float64视为通用数字类型，因为

整数没有内置的min或max函数，但编写自己的函数很简单。由于支持可变函数，我们甚至可以通过一次调用比较更多整数：

func MinOf(vars ...int) int {
    min := vars[0]

    for _, i := range vars {
        if min > i {
            min = i
        }
    }

    return min
}

用法：

MinOf(3, 9, 6, 2)

类似地，这里是max函数：

func MaxOf(vars ...int) int {
    max := vars[0]

    for _, i := range vars {
        if max < i {
            max = i
        }
    }

    return max
}

func MaxOf（vars…int）int{
最大值：=变量[0]
对于u，i:=范围变量{
如果max

虽然这个问题已经很老了，但我的软件包可能会对那些不喜欢重新发明自行车的人有所帮助。很少有函数可以找到两个整数中的最小值：

ix.Min

（对于

int

）、

i8.Min

（对于

int8

）、

ux.Min

（对于

uint

）等等。可以使用

go-get

获取包，通过URL和名为

type缩写.FuncName

的函数导入到项目中，例如：

主程序包
进口(
“fmt”
“/go imath/ix”
)
func main（）{
a、 b:=45，-42
fmt.Println（ix.Min（a，b））//输出：-42
}

可以使用：

导入(
“fmt”
“github.com/pkg/math”
)
func main（）{
a、 b:=45，-42
fmt.Println（math.Min（a，b））//输出：-42
}

如果您经常使用超过2个数字的min，您可以制作一个vararg版本的min，它简化了调用它的代码：例如：编写这样的代码在大多数其他语言中是不常见的。因此，我想问题是，至少我是这样来到这里的。并不是我不能写min函数，而是我不能相信它不存在……因为golang不包含多态性。您应该将函数命名为minInt或类似的名称，以便以后可以为int以外的其他数据类型创建类似的函数。@eshalev this

func min

是包的私有函数（因此仅在一小段代码中使用），

包排序

作者知道他们只需要两个索引中的较小者（不是浮动等），并且尝试传递浮点变量无论如何都不会起作用，因为没有类似C的隐式转换，所以我认为

min

在这里是合理的。当然，在其他地方，您可能需要为不同的类型编写实现，而func是公共的，因此潜在的使用范围更广，因此特定于类型的名称可以使ense，比如

sort.Ints

与

sort.Strings

+1，提醒人们（维基百科链接），更高的精度带来的代价是可能的（不太精确）可以表示的数字，给定一些恒定的位数。golang让您在每次需要min时为另一个浮动64的类型重写控制盘？此时声明的“简单性”会导致真正的复杂性。其中包括

min（）

函数。