Sorting an Array in Random Order

Question

I'm trying to understand how sorting an array in random order works. So, I found the following code:

var as = ["max","jack","sam"];  
var s = as.sort(func);  

function func(a, b) {  
  return 0.5 - Math.random();
}  

console.log(s);

my main question is why they use 0.5 not another number? and how it really works

Answer 1

Shortest Form (Using Lambda Expression):

To answer the question "How sorting of an array in random order works", as others have mentioned, the Array.sort() function can take a function as parameter.

Syntax:

Array.sort([sort_by_function()])

The inner sort_by_function() accepts two parameters (e.g.: x & y) and with use of Math.random() returns a value between -0.5 to 0.5, it returns:

• Negative number (-0.5 to -0.1), if x < y
• Zero (0), if x = y Positive
• Positive number (0.1 to 0.5), if x > y

Remember, if you don't pass in anything to the outer Array.sort() function, it simply rearranges/sorts the elements in Ascending order, if however, you pass in a function (as argument), then it behaves based on what the inner sort_by_function() returns, as it swaps EACH Element of the given array (by swapping pair of two elements at-a-time) essentially, this swapping is decided based on what the inner sort_by_function() returned.

To achieve random-sort order the Array.sort() function will rearrange/sort each pair of elements as below, for a:

• Negative value: swap in ascending order,
• Zero: no change,
• Positive value: swap in descending order.

Example:

arr.sort(function(x,y){return Math.random() - 0.5});

As no one mentioned about the use of the short Lambda expression, here is an example on how you can shorten the inner parameter-function by use of the Lambda expression as below:

arr.sort(() => Math.random() - 0.5);

Answer 2

If you call the sort method with a function parameter is called several times. This function should accept two parameters (let's call the first A and the second B) Each time it should return a value:

1. Less than zero, if A < B
2. Equal to zero, if A = B
3. Greater the zero, if A > B

So in this example we need random return values that evenly distribute negative and positive values. Since Math.random() returns a value between 0 and 1, 0.5 - Math.random() will return values between -0.5 and 0.5, which meets the requirements.

Answer 3

Math.random() returns a number between 0 and 1 (exclusive). We're using 0.5 because it is the mean value.

Array.sort() sorts the parameters based on the return value. So, 0.5 - Math.random() will yield either positive or negative value with equal probability. Hence, it will sort the parameters randomly.

How it really works

• If the return value of Array.sort() is positive, then the index of the first parameter will be higher than that of the second.
• If it is negative, then the index of the second parameter will be higher than that of the first.
• And, if it is 0, then do nothing.

Answer 4

You used

var as = ["max","jack","sam"];  
var s = as.sort(func);  

function func(a, b) {  
  return 0.5 - Math.random();
}  

console.log(s);

And here the most important thing is as.sort(func).
func(a,b) will return value in range of [-0.5,0.5].

Because this function return 0.5 - Math.random() and Math.random() will return the float value which is in range of [0,1].
So that your func will return value in range of [-0.5,0.5].

And this mean that sort order will be set increase or decrease. this is random. So your result will be random

var as = ["max","jack","sam"];  
var s = as.sort(func);  

function func(a, b) {  
  return Math.random();
}  

console.log(s);

var as = ["max","jack","sam"];  
var s = as.sort(func);  

function func(a, b) {  
  return 0 - Math.random();
}  

console.log(s);

var as = ["max","jack","sam"];  
var s = as.sort(func);  

function func(a, b) {  
  return 0.5 - Math.random();
}  

console.log(s);

Answer 5

If you just want to nudge the elements near their starting positions in a random way, sure, use sort with random, but in most cases, that's not what you want. You want to thoroughly shuffle an array, completely randomize the position of every element. And for that random in the built-in sort function is a terrible practice, because it is biased towards the initial state, meaning that the elements in the "shuffled" array will tend to stay near their positions (those that were near the beginning have the high probability of staying near the beginning, etc...). The bigger the size the array grows, the less it gets shuffled.

Here is the proof: Is it correct to use JavaScript Array.sort() method for shuffling?

And here is the function for shuffling arrays I use most of the time. It thoroughly randomizes the position of every element.

function shuffle(arr) { // randomly rearanges the items in an array
  const result = [];
  for (let i = arr.length-1; i >= 0; i--) {
    // picks an integer between 0 and i:
    const r = Math.floor(Math.random()*(i+1));   // NOTE: use a better RNG if cryptographic security is needed
    // inserts the arr[i] element in the r-th free space in the shuffled array:
    for(let j = 0, k = 0; j <= arr.length-1; j++) {
      if(result[j] === undefined) {
        if(k === r) {
          result[j] = arr[i];    // NOTE: if array contains objects, this doesn't clone them! Use a better clone function instead, if that is needed. 
          break;
        }
        k++;
      }
    }
  }
  return result;
}

Answer 6

Math.random() return random value between 0 to 1 (0 is included but 1 is excluded). So 0.5 act as mid point. If use use value like greater than 1 or less 0 than it will always be either true or false. So for this reason 0.5 is used.

You can read more here about Math.random()

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random

Let's understand it bit more with examples

var as = ["max","jack","sam"];  
var s = as.sort(func);  

function func(a, b) {  
  return 0.5 - Math.random();
}  

console.log(s);

This is what you get when you use value greater than 1

var as = ["max","jack","sam"];  
var s = as.sort(func);  

function func(a, b) {  
  return 1 - Math.random();
}  

console.log(s);

This is what happens when you use value less than 0

var as = ["max","jack","sam"];  
var s = as.sort(func);  

function func(a, b) {  
  return -1 - Math.random();
}  

console.log(s);

P.S :-

1. Try printing output from all the above condition you will see that last two condition will always return either true or false from function. so you will not get a random sorting.

2. Now talk about any value from 0 to 0.99 you can use any value but 0.5 will serve your purpose best.Because it's a middle point you're most likely to get best answer.

Answer 7

Math.random returns a number between 0 and 1.

Sorting function use the return value x as the following :

• x == 0 : Same value, can order "how it wants"

• x < 0 : the first object is less than the second one, therefore its index in the sorted array will be less than the other's

• x > 0 same as x < 0 but the other way around

Since Math.random returns a number between 0 and 1 and we want to also get negative numbers, we must subtract some value. Here 0.5 - Math.random() would give a number between 0.5 and -0.5