Converting from an integer to its binary representation
BinaryGoNumericBinary Problem Overview
Has anyone got an idea if there is any inbuilt functionality in Go for converting from any one of the numeric types to its binary number form.
For example, if 123 was the input, the string "1111011" would be the output.
Binary Solutions
Solution 1 - Binary
The strconv package has FormatInt, which accepts an int64 and lets you specify the base.
n := int64(123)
fmt.Println(strconv.FormatInt(n, 2)) // 1111011
DEMO: http://play.golang.org/p/leGVAELMhv
>http://golang.org/pkg/strconv/#FormatInt
>func FormatInt(i int64, base int) string
>FormatInt returns the string representation of i in the given base, for 2 <= base <= 36. The result uses the lower-case letters 'a' to 'z' for digit values >= 10.
Solution 2 - Binary
See also the fmt package:
n := int64(123)
fmt.Printf("%b", n) // 1111011
Solution 3 - Binary
This code works on big integers *big.Int :
x := big.NewInt(123)
s := fmt.Sprintf("%b", x)
// s == "1111011"
because *big.Int implements the fmt.Formatter interface.
Taken from https://stackoverflow.com/a/23317788/871134
Solution 4 - Binary
package main
import . "fmt"
func main(){
Printf("%d == %08b\n",0,0)
Printf("%d == %08b\n",1,1)
Printf("%d == %08b\n",2,2)
Printf("%d == %08b\n",3,3)
Printf("%d == %08b\n",4,4)
Printf("%d == %08b\n",5,5)
}
results in:
0 == 00000000
1 == 00000001
2 == 00000010
3 == 00000011
4 == 00000100
5 == 00000101
Solution 5 - Binary
Building on the answer provided by @Mark
Although the OP asked how to print an integer, I often want to look at more then 64 bits worth of data, without my eyes boggling:
/* --- Credit to Dave C in the comments --- */
package main
import (
"bytes"
"fmt"
)
func main() {
fmt.Printf("<%s>\n", fmtBits([]byte{0xDE, 0xAD, 0xBE, 0xEF, 0xF0, 0x0D, 0xDE, 0xAD, 0xBE, 0xEF, 0xF0, 0x0D}))
// OUTPUT:
// <11011110 10101101 10111110 11101111 11110000 00001101 11011110 10101101 10111110 11101111 11110000 00001101>
}
func fmtBits(data []byte) []byte {
var buf bytes.Buffer
for _, b := range data {
fmt.Fprintf(&buf, "%08b ", b)
}
buf.Truncate(buf.Len() - 1) // To remove extra space
return buf.Bytes()
}
Solution 6 - Binary
Unsafe pointers must be used to correctly represent negative numbers in binary format.
package main
import (
"fmt"
"strconv"
"unsafe"
)
func bInt(n int64) string {
return strconv.FormatUint(*(*uint64)(unsafe.Pointer(&n)), 2)
}
func main() {
fmt.Println(bInt(-1))
}
Solution 7 - Binary
An alternate way for the accepted answer would be to simply do
s := fmt.Sprintf("%b", 123)
fmt.Println(s) // 1111011
For a more rich representation you can use the unsafe package(strongly discouraged) as
a := int64(123)
byteSliceRev := *(*[8]byte)(unsafe.Pointer(&a))
byteSlice := make([]byte, 8)
for i := 0; i < 8; i++ {
byteSlice[i] = byteSliceRev[7 - i]
}
fmt.Printf("%b\n", byteSlice)
This works for negative integers too.
Solution 8 - Binary
Many above answers do not work if you use negative decimals.
Here is the simplest answer. Also works with negative decimals.
var a int64 = -1
fmt.Printf("%b\n", uint64(a)) // 11111.... (not -1)
You can also use fmt.Sprintf instead of fmt.Printf if you want a string variable.
This way, you can convert negative decimal into bitwise representation using two's complement (without - sign), not into mathematical binary representation (using - sign). (As I commented in Soslan's answer.)
(Soslan and Vaibhav's answers also work with negative numbers, using the unsafe package.)