6

I am confused about how arrays work in tandem with functions like Math.random(). Since the Math.random() function selects a number greater than or equal to 0 and less than 1, what specific number is assigned to each variable in an array? For example, in the code below, what number would have to be selected to print out 1? What number would have to be selected to print out jaguar?

var examples= [1, 2, 3, 56, "foxy", 9999, "jaguar", 5.4, "caveman"];
var example= examples[Math.round(Math.random() * (examples.length-1))];
console.log(example);

Is each element in an array assigned a position number equal to x/n (x being the position number relative to the first element and n being the number of elements)? Since examples has 9 elements, would 1 be at position 1/9 and would 9999 be at position 6/9?

Darien Springer
  • 467
  • 8
  • 17

4 Answers4

9

Math.round() vs. Math.floor()

The first thing to note: Math.round() is never the right function to use when you're dealing with a value returned by Math.random(). It should be Math.floor() instead, and then you don't need that -1 correction on the length. This is because Math.random() returns a value that is >= 0 and < 1.

This is a bit tricky, so let's take a specific example: an array with three elements. As vihan1086's excellent answer explains, the elements of this array are numbered 0, 1, and 2. To select a random element from this array, you want an equal chance of getting any one of those three values.

Let's see how that works out with Math.round( Math.random() * array.length - 1 ). The array length is 3, so we will multiply Math.random() by 2. Now we have a value n that is >= 0 and < 2. We round that number to the nearest integer:

If n is >= 0 and < .5, it rounds to 0.
If n is >= .5 and < 1.5, it rounds to 1.
If n is >= 1.5 and < 2, it rounds to 2.

So far so good. We have a chance of getting any of the three values we need, 0, 1, or 2. But what are the chances?

Look closely at those ranges. The middle range (.5 up to 1.5) is twice as long as the other two ranges (0 up to .5, and 1.5 up to 2). Instead of an equal chance for any of the three index values, we have a 25% chance of getting 0, a 50% chance of getting 1, and a 25% chance of 2. Oops.

Instead, we need to multiply the Math.random() result by the entire array length of 3, so n is >= 0 and < 3, and then floor that result: Math.floor( Math.random() * array.length ) It works like this:

If n is >= 0 and < 1, it floors to 0.
If n is >= 1 and < 2, it floors to 1.
If n is >= 2 and < 3, it floors to 2.

Now we clearly have an equal chance of hitting any of the three values 0, 1, or 2, because each of those ranges is the same length.

Keeping it simple

Here is a recommendation: don't write all this code in one expression. Break it up into simple functions that are self-explanatory and make sense. Here's how I like to do this particular task (picking a random element from an array):

// Return a random integer in the range 0 through n - 1
function randomInt( n ) {
    return Math.floor( Math.random() * n );
}

// Return a random element from an array
function randomElement( array ) {
    return array[ randomInt(array.length) ];
}

Then the rest of the code is straightforward:

var examples = [ 1, 2, 3, 56, "foxy", 9999, "jaguar", 5.4, "caveman" ];
var example = randomElement( examples );
console.log( example );

See how much simpler it is this way? Now you don't have to do that math calculation every time you want to get a random element from an array, you can simply call randomElement(array).

Community
  • 1
  • 1
Michael Geary
  • 28,450
  • 9
  • 65
  • 75
7

They're is quite a bit happening so I'll break it up:

Math.random

You got the first part right. Math.random will generate a number >= 0 and < 1. Math.random can return 0 but chances are almost 0 I think it's like 10^{-16} (you are 10 billion times more likely to get struck by lightning). This will make a number such as:

0.6687583869788796

Let's stop there for a second

Arrays and their indexes

Each item in an array has an index or position. This ranges from 0 - infinity. In JavaScript, arrays start at zero, not one. Here's a chart:

[ 'foo', 'bar', 'baz' ]

Now the indexes are as following:

name | index
-----|------
foo  | 0
bar  | 1
baz  | 2

To get an item from it's index, use []:

fooBarBazArray[0]; // foo
fooBarBazArray[2]; // baz

Array length

Now the array length won't be the same as the largest index. It will be the length as if we counted it. So the above array will return 3. Each array has a length property which contains it's length:

['foo', 'bar', 'baz'].length; // Is 3

More Random Math

Now let's take a look at this randomizing thing:

Math.round(Math.random() * (mathematics.length-1))

They're is a lot going on. Let's break it down:

Math.random()

So first we generate a random number.

* mathematics.length - 1

The goal of this random is to generate a random array index. We need to subtract 1 from the length to get the highest index.

First Part conclusions

This now gives us a number ranging from 0 - max array index. On the sample array I showed earlier:

Math.random() * (['foo', 'bar', 'baz'].length - 1)

Now they're is a little problem:

This code makes a random number between 0 and the length. That means the -1 shouldn't be there. Let's fix this code:

Math.random() * ['foo', 'bar', 'baz'].length

Running this code, I get:

2.1972009977325797
1.0244733088184148
0.1671080442611128
2.0442249791231006
1.8239217158406973

Finally

To get out random index, we have to make this from an ugly decimal to a nice integer: Math.floor will basically truncate the decimal off.

Math.floor results:

2
0
2
1
2

We can put this code in the [] to select an item in the array at the random index.

More Information / Sources

Downgoat
  • 13,771
  • 5
  • 46
  • 69
  • 1
    "will generate a number > 0 and < 1" --- that's not correct, it generates numbers in the `[0; 1)` range. – zerkms May 30 '15 at 06:28
  • So if I apply '.length' to a Math.random function then the Math.floor function will generate a number greater than or equal to 0 and less than the max array index (which in this case would be less than 3 because there are three variables in the code that @vihan1086 gave as an example). To summarize, using .length with the Math.random function changes the range from [0;1) to [0;3). Does this sound correct ? – Darien Springer May 30 '15 at 06:51
  • 1
    @DarienSpringer - You have it right! See my answer for a detailed example of how this works out with `Math.floor()` and why you shouldn't use `Math.round()`. – Michael Geary May 30 '15 at 07:38
  • So Math.floor() creates an equal chance of Math.random() selecting any of the variables in the array while Math.round would create a situation where some variables would be more likely to be selected than others because of how Math.round() determines what numbers would be adjusted to (some integers would have twice as much of a likelihood of being selected as others). – Darien Springer May 30 '15 at 07:49
  • That's exactly right: with rounding, the first and last elements have only half the chance of being selected as any of the other elements. For example, with five elements the chances for each element would be 12.5%, 25%, 25%, 25%, 12.5%. – Michael Geary May 30 '15 at 08:07
  • 1
    @zerkms - I took the liberty of correcting that to read ">= 0 and < 1". – Michael Geary Jun 06 '15 at 16:34
2

You're looking at simple multiplication, and a bug in your code. It should reference the array 'examples' that you are selecting from, instead of some thing you haven't mentioned called 'mathematics':

var example = examples[Math.round(Math.random() * (examples.length-1))];
                                                     ^^

Then you're just multiplying a random number by the number of things in the array. So the maximum random number is 1 and if there are 50 things in your array you multiply the random number by 50, and now the maximum random number is 50.

And all the smaller random numbers (0 to 1) are also scaled 50x and now spread from (0 to 50) with roughly the same randomness to them. Then you round it to the nearest whole number, which is a random index into your array from 1 to n, and you can do element[thatnumber] to pick it out.

Full examples:

Math.random() returns numbers between 0 and 1 (it can return 0 but chances of that are incredibly small):

Math.random()
0.11506261994225964
Math.random()
0.5607304393516861
Math.random()
0.5050221864582
Math.random()
0.4070177578793308
Math.random()
0.6352060229006462

Multiply those numbers by something to scale them up; 1 x 10 = 10 and so Math.random() * 10 = random numbers between 0 and 10.

Math.random() *n returns numbers between 0 and n:

Math.random() * 10
2.6186012867183326
Math.random() * 10
5.616868671026196
Math.random() * 10
0.7765205189156167
Math.random() * 10
6.299650241067698

Then Math.round(number) knocks the decimals off and leaves the nearest whole number between 1 and 10:

Math.round(Math.random() * 10)
5

Then you select that numbered element:

examples[  Math.round(Math.random() * 10)  ];

And you use .length-1 because indexing counts from 0 and finishes at length-1, (see @vihan1086's explanation which has lots about array indexing).

This approach is not very good at being random - particularly it's much less likely to pick the first and last elements. I didn't realise when I wrote this, but @Michael Geary's answer is much better - avoiding Math.round() and not using length-1.

Downgoat
  • 13,771
  • 5
  • 46
  • 69
TessellatingHeckler
  • 27,511
  • 4
  • 48
  • 87
  • 2
    Sorry, but `Math.round()` and subtracting 1 from the array length are wrong. This does not give you equal chances of hitting each array element. See my answer for a detailed explanation and the correct approach. – Michael Geary May 30 '15 at 07:33
  • 2
    @MichaelGeary Your answer is more evenly random, which is overall better - I didn't realise how wrong mine is in that respect. But you are also focusing on the bit Darien said he didn't care about (quality of randomness) and skipping the more basic bit I thought he didn't understand - *Does every variable in the array take up an equal amount of the length from greater than or equal to 0 and less than 1?* - he's missing the understanding about multiplication scaling the random range, which you gloss over with *so we will multiply Math.random() by 2*. I've upvoted you and edited me. – TessellatingHeckler May 30 '15 at 07:56
0

This is an old question but I will provide a new and shorter solution to get a random item from an array.

Math.random

It returns a number between 0 and 1 (1 not included).

Bitwise not ~

This operator behaves returning the oposite value that you are providing, so:

a = 5
~a // -5

It also forgets about decimals, so for instance:

a = 5.95
~a // -5

It is skipping the decimals, so somehow it behaves like Math.floor (without returning a negative value, of course).

Doubled operators

Negative logical operator !, used to coerce to a boolean type is !!null // false and we are forcing it by double negation. If we use the same idea but for numbers, we are forcing a number to floor if we do: ~~5.999 // 5

Therefore,

TLDR;

getRandom = (arr, len = arr.length) => arr[~~(Math.random() * len)]

example:

getRandom([1,2,3,4,5]) // random item between 1 and 5
llobet
  • 2,672
  • 23
  • 36