How do you do random?

I was watching a VueJS tutorial and was surprised at what it takes in ECMAscript to generate a random integer between 0 and 10.

Math.floor(Math.random() * 10);

In PHP it takes

mt_rand(0, 10);

In your favorite language what does it take to generate an integer between 0 and 10?

Comments

[kip]

From a terminal can be(no for encrypt things):

> shuf -i 0-10 -n 1
4
>

[David J Eddy]

They see me shuffling. LMFAO

[rhymes]

Python:

import random
random.randint(0, 10)

Ruby:

rand(11)

Go:

import "math/rand"

func main() {
    rand.Intn(11)
}

None of these are cryptographically secure though

[Rishabh Gupta]

Python has a cryptographically secure library called "secrets", which I use a lot :-P

[rhymes]

Yeah secrets is very useful and has a clear API

[APixel Visuals]

JS still works better than C to randomly generate and have the numbers actually be random 👀

[JavaScript Joel]

Math.random() produces a random float (all JavaScript numbers are of type float) from 0 to 1.

Adding the requirement of 0-10 means you have to multiply by 10 or * 10.

The last requirement was the number must be an Integer, which is the math.floor.

Of course, if you only wanted a random float between 0 and 1, it would be just one call.

And in PHP if you wanted a random float between 0 and 1, you would also have to do more work: Random Float between 0 and 1 in PHP

So the complexity actually comes from the requirements you give it.

But asking for a random integer is a common task. So it's handy to create function and keep it in your library. Don't go sprinkling Math.floor(Math.random() * 10) randomly around your codebase :D

const pseudoRandomInteger = (start, end) =>
  start + Math.floor(Math.random() * (end - start))

P.S. I prefixed this with pseudo because there is no true Random in JavaScript. This is very important when it comes to cryptography. Google PRNG if you want to learn more.

For a cryptographically strong random value, you might want to look into Crypto.getRandomValues()

Cheers!

[Jochem Stoel]

const between = (min, max) => Math.floor(Math.random() * max) + min

[David J Eddy]

...the complexity actually comes from the requirement...

I wish PM's understood this more.

[Klemen Slavič]

There's a bug in your example; if the output is supposed to be [start, end), then the correct implementation is:

const pseudoRandomInteger = (start, end) =>
  start + Math.floor(Math.random() * (end - start));

✌😉

[JavaScript Joel]

I probably should have run it once. lol.

I gotta stop typing code directly into editors.

Good catch!

[Boris Jamot ✊ /]

cat /dev/random 

[Rishabh Gupta]

Going the OG route

[Tetri Mesquita]

const random = 7;

[Elliot Derhay]

🤣

[Fran González]

xkcd.com/221/

[Yaser Al-Najjar]

You made my day 🤣🤣

[Mihail Malo]

Pfff, everyone knows random is 4 not 7.

[Tetri Mesquita]

Pfff, you need update your mindset 🤨

[Mihail Malo]

Updates just break everything.
How can you know that no consumer of your code assumes it will be 4?
Sure, you claimed it is random, in the "documentation", but it's not like that ever works.

There are probably children out there holding down spacebar to stay warm in the winter! YOUR UPDATE MURDERS CHILDREN.

[Will F]

Python has a few options, including the numpy module. Regardless of language, however, it often only takes a ~20 lines to define a pseudo-random (in numerical math we avoid saying "random") number generator method. Here is an implementation of the so-called Mersenne twister:

def rando(n, seed, S = [0, 10, 'integer']):
    i = int(16807)
    j = int(2147483647)
    u_list = []
    if S[2] == 'real':
        for k in range(n):
            seed = (i * seed) % j
            u = (S[1] - S[0]) * (float(seed) / float(j)) + S[0]
            u_list.append(u)
        return u_list
    elif S[2] == 'integer':
        for k in range(n):
            seed = (i * seed) % j
            u = int((S[1] - S[0] + 1) * (float(seed) / float(j)) + S[0])
            u_list.append(u)
        return u_list
    else:
        print('Set of numbers to draw from is undefined')

In this method, we declare two integers, i (16807 = 7^5), and j (the Mersenne prime). In specifying the arguments n (number of psuedo-random numbers desired), seed (for repeatability of the pseudo-random numbers), and S (min, max, types to be generated), what is repeatedly happening (depending on n) is that we are taking the remainder of (seed * i) and j, and dividing by j; over and over. This implementation of the Mersenne Twister is good for about 2³⁰ random numbers before it repeats itself. :)

[Adrian B.G.]

Others responded on-topic, so I would add an off-topic :)

I do not build a JS project without Lodash (or something similar), it covers the basic needs and lacks of JS, acting like a Standard library in other languages. A few of them are related to random

_.random([lower=0], [upper=1], [floating])

_.sample(collection) //get a random element
_.sampleSize(collection, [n=1])

But, statistically speaking, taking a float random and truncating it to just a small integer range it's like buying a Ferrari for commuting, just saying :D Most of the times is a waste of resources.

Devs should be more careful at the distributions, most of the cases the code will be used for a few values and a small range of values, which will lead to very not-so-random results.

If the random results will affect the User Experience you should think twice of using it, the screwed distribution will affect your sales and KPIs in unknown ways, most likely negative, and there are always better alternatives, that require more resources to implement of course.

[Arie Beresteanu]

real(8) :: r
integer :: i

CALL RANDOM_NUMBER(r)
i = floor(r *10.0)

[Devin W. Leaman]

I originally found it on the Hey, Scripting Guy! blog, but it's pretty simple to use:

Get-Random -Count 2 -InputObject (1..10)

Where Count is how many random numbers you wish to generate, and InputObject is an array of the range of numbers you want to choose from.