Join digits from integer array into one number in Golang?

I have an array of integers:

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

How could I make integer 123 out of that?

I appreciate @KelvinS' approach, there already exists a math.Pow (though it deals in float64s. Never-the-less, his approach breaks down what you are really after, which is raising each successive number (from the right) by an order of magnitude and summing the numbers. As such, the most straight forward approach I can think of is

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 is poorly named, but you should get the idea.

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

It may be a micro optimization to try to get this as fast as possible, but if it happens to be in a hot path it might be worth it

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

Try something like this:

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)
	}
}

Maybe there is a better way to do this, but this example works.

You can also iterate over the slice and build the int with arithmetic

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)
}

Iterate over your slice and add each item to a buffer:

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

You can then convert it into an integer using the strconv package.

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

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

To me the simplest approach is:

1. Convert slice of ints to slice of strings

2. Join the strings

3. Convert resulting string into an 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))
   

   }

Result:

123
1203

Converting slice of ints to strings, and then joining is O(N), as opposed to incrementally building out the final string, which is O(N * N).