Question

我有一个整数数组：

nums := []int{1, 2, 3}

我怎样才能制作整数123？

Answer 1

尝试这样的事情：

package main

import (
    "strconv"
    "log"
)

func join(nums []int) (int, error) {
    var str string
    for i := range nums {
        str += strconv.Itoa(nums[i])
    }
    num, err := strconv.Atoi(str)
    if err != nil {
        return 0, err
    } else {
        return num, nil
    }
}

func main() {
    nums := []int{1, 2, 3}
    num, err := join(nums)
    if err != nil {
        log.Println(err)
    } else {
        log.Println(num)
    }
}

也许有更好的方法可以做到这一点，但这个例子有效。

Answer 2

我很欣赏@KelvinS的方法，已经存在math.Pow（尽管它处理的是float64s。从不如此，他的方法打破了你真正追求的东西，这会提高每个连续的数字（来自右边）一个数量级并总结数字。因此，我能想到的最直接的方法是

func sliceToInt(s []int) int {
    res := 0
    op := 1
    for i := len(s) - 1; i >= 0; i-- {
        res += s[i] * op
        op *= 10
    }
    return res
}

func main() {
    nums := []int{1, 2, 3}
    fmt.Println(sliceToInt(nums))
}

sliceToInt命名不佳，但你应该明白这一点。

https://play.golang.org/p/JS96Nq_so-

尝试尽可能快地获得此优势可能是微优化，但如果它恰好在热门路径中可能是值得的

BenchmarkPow-8              100000000           13.5 ns/op         0 B/op          0 allocs/op
BenchmarkJoin-8              5000000           272 ns/op           8 B/op          5 allocs/op
BenchmarkBuffer-8            2000000           782 ns/op         160 B/op          8 allocs/op
BenchmarkSliceToInt-8       200000000            8.65 ns/op        0 B/op          0 allocs/op
PASS

Answer 3

您还可以迭代切片并使用算术

构建int

package main

import (
    "fmt"
)

func Pow(a, b int) int {
    result := 1
    for i := 0; i < b; i++ {
        result *= a
    }
    return result
}

func main() {
    nums := []int{1, 2, 3}
    num := 0
    length := len(nums)
    for i, d := range nums {
        num += d * Pow(10, length-i-1)
    }
    fmt.Println(num)
}

Answer 4

迭代切片并将每个项目添加到缓冲区：

var buf bytes.Buffer
nums := []int{1, 2, 3}
for i := range nums {
    buf.WriteString(fmt.Sprintf("%d", nums[i]))
}

然后，您可以使用strconv包将其转换为整数。

i, err := strconv.Atoi(buf.String())

GoPlay：
https://play.golang.org/p/8w-gc2S2xR

Answer 5

对我而言，最简单的方法是：

1）将整数切片转换为字符串切片

2）加入字符串

3）将结果字符串转换为int

package main

import (
    "fmt"
    "strconv"
    "strings"
)

func sliceToInt(ints []int) int {
    stringVals := make([]string, len(ints))

    for ind, val := range ints {
        stringVals[ind] = strconv.Itoa(val)
    }

    newInt, _ := strconv.Atoi(strings.Join(stringVals, ""))

    return newInt

}

func main() {
    s1 := []int{1, 2, 3}
    fmt.Println(sliceToInt(s1))

    s2 := []int{1, 20, 3}
    fmt.Println(sliceToInt(s2))
}

结果：

123
1203

将int切片转换为字符串，然后连接为O（N），而不是逐步构建最终字符串，即O（N * N）。

将整数数组中的数字连接到Golang中的一个数字？

5 个答案: