How to get a sample of random numbers in golang? [closed] - go

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 4 years ago.
Improve this question
Or I have to use straightforward way like:
var arr []int
for i := 0; i < 5; i++ {
arr = append(arr, rand.Intn(100))
}

What you did is clean and fast enough. What you could improve on it is to pre-allocate the slice and fill it using a for.. range loop like this:
s := make([]int, 5)
for i := range s {
s[i] = rand.Intn(100)
}
The math/rand package also has a rand.Read() function which fills a slice with random bytes. So if you want to fill a []byte slice with random data, this is all it takes:
s := make([]byte, 100)
rand.Read(s) // This never returns an error
Another interesting way would be to take advantage of rand.Rand being an io.Reader. Which means it has a Read() method which fills a []byte with random data.
This combined with the encoding/binary package, you can "fill" variables with random data. Create and pass a rand.Rand to the binary.Read() function as the source, and that's it.
This is how it would look like:
r := rand.New(rand.NewSource(time.Now().UnixNano()))
s := make([]int32, 5)
err := binary.Read(r, binary.BigEndian, &s)
if err != nil {
panic(err)
}
fmt.Println(s)
Output:
[203443513 1611652563 -235795288 8294855 -802604260]
This is "cool" enough to even fill structs for example:
var point struct{ X, Y int16 }
err = binary.Read(r, binary.BigEndian, &point)
if err != nil {
panic(err)
}
fmt.Printf("%+v", point)
Output:
{X:-15471 Y:2619}
Try these examples on the Go Playground.
One handicap of using binary.Read() is that–understandably–it can only fill values of fixed-size types, and the most famous exception is the common int type, whose size is not fixed (architecture dependent). So you can't fill an []int slice or a struct with a field of int type. That's why I used int32 and int16 types in the above examples.
Of course in these solutions you could not limit the range of random numbers that are used to fill your variables. For that, the initial loop is still easier.

Related

How to generate alphabet slice [closed]

Closed. This question is not reproducible or was caused by typos. It is not currently accepting answers.
This question was caused by a typo or a problem that can no longer be reproduced. While similar questions may be on-topic here, this one was resolved in a way less likely to help future readers.
Closed 1 year ago.
Improve this question
I'm trying to generate an alphabet slice.
This is all I have so far
letters := []string{}
alphabet := []string{}
for i := 'A'; i <= 'Z'; i++ {
alphabet := append(letters, "a")
}
fmt.Println(alphabet)
This doesn't work. Can someone help me out?
Your program has some bugs because of which you're not getting the desired output. I've added comments to your code so that you can have a basic idea of where are you doing it incorrectly.
package main
import "fmt"
func main() {
// we don't really need the two slice
letters := []string{}
alphabet := []string{}
for i := 'A'; i <= 'Z'; i++ {
// alphabet declared but not used (compile error)
alphabet := append(letters, "a") // why hard-code "a"? wrong!
}
// print a slice of string? wrong!
// each character could be stored in byte or rune and then the slice could
// converted to string
fmt.Println(alphabet)
}
The following code might help:
package main
import "fmt"
func main() {
// Pre-allocate slice for storing 26 letters
// Note: Instead of []byte, we can use []rune as well
// But as our scope is limited to storing 'A' to 'Z' only
// byte is enought to hold each letter.
alphabet := make([]byte, 0, 26)
// Loop over 'A' to 'Z' and keep on appending
// to alphabet slice
var ch byte
for ch = 'A'; ch <= 'Z'; ch++ {
alphabet = append(alphabet, ch)
}
// Print alphabet
fmt.Println(string(alphabet))
}
With alphabet := append(letters, string(i)), you are creating a new object every time due to : and the outer one is not used.
alphabet := []string{}
for i := 'A'; i <= 'Z'; i++ {
alphabet = append(alphabet, string(i))
}
fmt.Println(alphabet)
Also, you don't need letters object as you can append on the alphabet as you go along and assign the returned object to itself.
Update: I agree with #shmsr that using string slice is an overkill if you just want to store a byte of data so you can use byte slice as:
alphabet := []byte{}
var i byte
for i = 'A'; i <= 'Z'; i++ {
alphabet = append(alphabet, i)
}
fmt.Println(string(alphabet)) // need explicit type conversion though else it prints ascii values by default
Note: You need an explicit type conversion though otherwise it prints ascii values by default.

Adding/subtracting two numeric strings

I have two variables with big numbers set as strings:
var numA = "340282366920938463463374607431768211456"
var numB = "17014118346046923173168730371588410572"
I want to be able to add and subtract these kinds of large string numbers in Go.
I know I need to use math/big but I still can not for the life of me figure out how, so any example help will be greatly appreciated!
You may use big.NewInt() to create a new big.Int value initialized with an int64 value. It returns you a pointer (*big.Int). Alternatively you could simply use the builtin new() function to allocate a big.Int value which will be 0 like this: new(big.Int), or since big.Int is a struct type, a simple composite literal would also do: &big.Int{}.
Once you have a value, you may use Int.SetString() to parse and set a number given as string. You can pass the base of the string number, and it also returns you a bool value indicating if parsing succeeded.
Then you may use Int.Add() and Int.Sub() to calculate the sum and difference of 2 big.Int numbers. Note that Add() and Sub() write the result into the receiver whose method you call, so if you need the numbers (operands) unchanged, use another big.Int value to calculate and store the result.
See this example:
numA := "340282366920938463463374607431768211456"
numB := "17014118346046923173168730371588410572"
ba, bb := big.NewInt(0), big.NewInt(0)
if _, ok := ba.SetString(numA, 10); !ok {
panic("invalid numA")
}
if _, ok := bb.SetString(numB, 10); !ok {
panic("invalid numB")
}
sum := big.NewInt(0).Add(ba, bb)
fmt.Println("a + b =", sum)
diff := big.NewInt(0).Sub(ba, bb)
fmt.Println("a - b =", diff)
Output (try it on the Go Playground):
a + b = 357296485266985386636543337803356622028
a - b = 323268248574891540290205877060179800884

Working with bitstrings and big.Int in Go

I'm new to Go and I'm working on a few exercises to get up to speed. How can I convert a string representing a sequence of bits to the appropriate datatype in Go?
For eg, I see that if its a bitstring representing a 64-bit number, I can do :-
val, err := strconv.ParseInt(bitstring, 2, 64)
However, if the bitstring represents a larger number(say 1024 or 2048 bits), how can I go about converting that number to the appropriate type in Go? I believe the type for managing big integers in Go is big.Int.
Yes, you may use the big.Int type, and its Int.SetString() method, passing 2 as the base.
Example:
i := big.NewInt(0)
if _, ok := i.SetString("10101010101010101010101010101010101010101010101010101010101010101010101010", 2); !ok {
fmt.Println("Invalid number!")
} else {
fmt.Println(i)
}
Output (try it on the Go playground):
12592977287652387236522

Slice merge in golang recommendation

Is there a way to make this golang code shorter?
func MergeSlices(s1 []float32, s2 []int32) []int {
var slice []int
for i := range s1 {
slice = append(slice, int(s1[i]))
}
for i := range s2 {
slice = append(slice, int(s2[i]))
}
return slice
}
You can't eliminate the loops to convert each element to int individually, because you can't convert whole slices of different element types. For explanation, see this question: Type converting slices of interfaces in go
The most you can do is use named result type, and a for range with 2 iteration values, where you can omit the first (the index) by assigning it to the blank identifier, and the 2nd will be the value:
func MergeSlices(s1 []float32, s2 []int32) (s []int) {
for _, v := range s1 {
s = append(s, int(v))
}
for _, v := range s2 {
s = append(s, int(v))
}
return
}
But know that your code is fine as-is. My code is not something to always follow, it was to answer your question: how to make your code shorter. If you want to improve your code, you could start by looking at its performance, or even refactoring your code to not end up needing to merge slices of different types.
Your code should be correct, maintainable, readable, and reasonably efficient. Note that shortness of code is not one of the important goals. For good reason, Stack Exchange has another site for Code Golf questions: Programming Puzzles & Code Golf.
Your code could be improved; it's inefficient. For example, merging two len(256) slices,
BenchmarkMergeSlices 200000 8350 ns/op 8184 B/op 10 allocs/op
Here's a more efficient (and longer) version:
BenchmarkMergeSlices 300000 4420 ns/op 4096 B/op 1 allocs/op
.
func MergeSlices(s1 []float32, s2 []int32) []int {
slice := make([]int, 0, len(s1)+len(s2))
for i := range s1 {
slice = append(slice, int(s1[i]))
}
for i := range s2 {
slice = append(slice, int(s2[i]))
}
return slice
}
Use the Go Code Review Comments for Named Result Parameters. For example: "Don't name result parameters just to avoid declaring a var inside the function; that trades off a minor implementation brevity at the cost of unnecessary API verbosity. Clarity of docs is always more important than saving a line or two in your function."
var s1 []int
var s2 []int
newSlice = append(s1, s2...)
The code can't get any shorter, but that's a goal of dubious value to begin with; it's not overly verbose as-is. You can, however, likely improve performance by eliminating the intermediate allocations. Every time you call append, if the target slice doesn't have enough space, it expands it, guessing at the necessary size since you haven't told it how much space it will need.
The simplest would just be to presize your target slice (replace var slice []int with slice := make([]int, 0, len(s1) + len(s2)); that way the appends never have to expand it. Setting the second parameter to 0 is important, that sets the length to zero, and the capacity to the total size needed, so that your appends will work as expected.
Once you've presized it though, you can get rid of the appends entirely, and directly set each index:
func MergeSlices(s1 []float32, s2 []int32) []int {
slice := make([]int, len(s1) + len(s2))
for i,v := range s1 {
slice[i] = int(v)
}
for i,v := range s2 {
slice[i+len(s1)] = int(v)
}
return slice
}
Playground link

How to generate a fixed length random number in Go?

What is the fastest and simplest way to generate fixed length random numbers in Go?
Say to generate 8-digits long numbers, the problem with rand.Intn(100000000) is that the result might be far less than 8-digits, and padding it with leading zeros doesn't look like a good answer to me.
I.e., I care about the the quality of the randomness more in the sense of its length. So I'm thinking, for this specific problem, would the following be the fastest and simplest way to do it?
99999999 - rand.Int63n(90000000)
I.e., I guess Int63n might be better for my case than Intn. Is it ture, or it is only a wishful thinking? Regarding randomness of the full 8-digits, would the two be the same, or there is really one better than the other?
Finally, any better way than above?
UPDATE:
Please do not provide low + rand(hi-low) as the answer, as everyone knows that. It is equivalent of what I'm doing now, and it doesn't answer my real question, "Regarding randomness of the full 8-digits, would the two be the same, or there is really one better than the other? "
If nobody can answer that, I'll plot a 2-D scatter plot between the two and find out myself...
Thanks
This is a general purpose function for generating numbers within a range
func rangeIn(low, hi int) int {
return low + rand.Intn(hi-low)
}
See it on the Playground
In your specific case, trying to generate 8 digit numbers, the range would be (10000000, 99999999)
It depend on value range you want to use.
If you allow value range [0-99999999] and padding zero ip number of char < 8, then use fmt like fmt.Sprintf("%08d",rand.Intn(100000000)).
If you dont want padding, which value in range [10000000, 99999999], then give it a base like ranNumber := 10000000 + rand.Intn(90000000)`
See it on Playground
crypto/rand package is used to generate number.
func generateRandomNumber(numberOfDigits int) (int, error) {
maxLimit := int64(int(math.Pow10(numberOfDigits)) - 1)
lowLimit := int(math.Pow10(numberOfDigits - 1))
randomNumber, err := rand.Int(rand.Reader, big.NewInt(maxLimit))
if err != nil {
return 0, err
}
randomNumberInt := int(randomNumber.Int64())
// Handling integers between 0, 10^(n-1) .. for n=4, handling cases between (0, 999)
if randomNumberInt <= lowLimit {
randomNumberInt += lowLimit
}
// Never likely to occur, kust for safe side.
if randomNumberInt > int(maxLimit) {
randomNumberInt = int(maxLimit)
}
return randomNumberInt, nil
}
I recently needed to do something like this, but with a certain byte length (rather than number of digits) and with numbers larger than max int64 (so using math/big.Int). Here was my general solution:
See on the Playground (with added code comments)
func generateRandomBigInt(numBytes int) (*big.Int, error) {
value := make([]byte, numBytes)
_, err := rand.Reader.Read(value)
if err != nil {
return nil, err
}
for true {
if value[0] != 0 {
break
}
firstByte := value[:1]
_, err := rand.Reader.Read(firstByte)
if err != nil {
return nil, err
}
}
return (&big.Int{}).SetBytes(value), nil
}

Resources