Question

Ok so i need to create four randomly generated numbers between 1-10 and they cannot be the same. so my thought is to add each number to an array but how can I check to see if the number is in the array, and if it is, re-generate the number and if it isnt add the new number to the array?

so basically it will go,

1.create new number and add to array
2.create second new number, check to see if it exist already, if it doesn’t exist, add to array. If it does exist, re-create new number, check again etc…
3.same as above and so on.

Answer 1

You want what is called a ‘random grab bag’. Consider you have a ‘bag’ of numbers, each number is only represented once in this bag. You take the numbers out, at random, for as many as you need.

The problem with some of the other solutions presented here is that they randomly generate the number, and check to see if it was already used. This will take longer and longer to complete (theoretically up to an infinite amount of time) because you are waiting for the random() function to return a value you don’t already have (and it doesn’t have to do that, it could give you 1-9 forever, but never return 10).

There are a lot of ways to implement a grab-bag type solution, each with varying degrees of cost (though, if done correctly, won’t ever be infinite).

The most basic solution to your problem would be the following:

var grabBag = [1,2,3,4,5,6,7,8,9,10];

// randomize order of elements with a sort function that randomly returns -1/0/1
grabBag.sort(function(xx,yy){ return Math.floor(Math.random() * 3) - 1; })

function getNextRandom(){
    return grabBag.shift();
};

var originalLength = grabBag.length;
for(var i = 0; i < originalLength; i++){
    console.log(getNextRandom());
}

This is of course destructive to the original grabBag array. And I’m not sure how ‘truly random’ that sort is, but for many applications it could be ‘good enough’.

An slightly different approach would be to store all the unused elements in an array, randomly select an index, and then remove the element at that index. The cost here is how frequently you are creating/destroying arrays each time you remove an element.