How to generate a new random number (that's different from the previous random number)

Question

I'm trying to change the following (that currently returns a random number from an array), so that each random number is different from the last one chosen.

function randomize(arr) {
            return arr[Math.floor(Math.random()*arr.length)];
        }

oracleImg = [];
          for (var i=1;i<=6;i++) {
          oracleImg.push(i);
        } 

randOracleImg = randomize(oracleImg);

I tried the following, but it's not always giving me a number different from the last number.

function randomize(arr) {
    var arr = Math.floor(Math.random()*arr.length);
    if(arr == this.lastSelected) {
          randomize();
        }
        else {
            this.lastSelected = arr;
            return arr;
        }
}

How can I fix this?

Answer 1

If you want to ALWAYS return a different number from an array then don't randomize, shuffle instead!*

The simplest fair (truly random) shuffling algorithm is the Fisher-Yates algorithm. Don't make the same mistake Microsoft did and try to abuse .sort() to implement a shuffle. Just implement Fisher-Yates (otherwise known as the Knuth shuffle):

// Fisher-Yates shuffle:
// Note: This function shuffles in-place, if you don't
//       want the original array to change then pass a copy
//       using [].slice()
function shuffle (theArray) {
    var tmp;
    for (var i=0; i<theArray.length;i++) {
        // Generate random index into the array:
        var j = Math.floor(Math.random()*theArray.length);

        // Swap current item with random item:
        tmp = theArray[i];
        theArray[j] = theArray[i];
        theArray[i] = tmp;
    }
    return theArray;
}

So just do:

shuffledOracleImg = shuffle(oracleImg.slice());

var i=0;

randOracleImg = shuffledOracleImg[i++]; // just get the next image
                                        // to get a random image

How you want to handle running out of images is up to you. Media players like iTunes or the music player on iPhones, iPads and iPods give users the option of stop playing or repeat from beginning. Some card game software will reshuffle and start again.

*note: One of my pet-peeves is music player software that randomize instead of shuffle. Randomize is exactly the wrong thing to do because 1. some implementations don't check if the next song is the same as the current song so you get a song played twice (what you seem to want to avoid) and 2. some songs end up NEVER getting played. Shuffling and playing the shuffled playlist from beginning to end avoids both problems. CD player manufacturers got it right. MP3 player developers tend to get it wrong.

Answer 2

here is a version which will ensure a random number that is always different from the last one. additionally you can control the max and min value of the generated random value. defaults are max: 100 and min: 1

var randomize = (function () {
    var last;
    return function randomize(min, max) {
        max = typeof max != 'number' ? 100 : max;
        min = typeof min != 'number' ? 1 : min;

        var random = Math.floor(Math.random() * (max - min)) + min;
        if (random == last) {
            return randomize(min, max);
        }

        last = random;
        return random;
    };
})();

Answer 3

Your existing function's recursive randomize() call doesn't make sense because you don't pass it the arr argument and you don't do anything with its return value. That line should be:

return randomize(arr);

...except that by the time it gets to that line you have reassigned arr so that it no longer refers to the original array. Using an additional variable as in the following version should work.

Note that I've also added a test to make sure that if the array has only one element we return that item immediately because in that case it's not possible to select a different item each time. (The function returns undefined if the array is empty.)

function randomize(arr) {
    if (arr.length < 2) return arr[0];
    var num = Math.floor(Math.random()*arr.length);
    if(num == this.lastSelected) {
        return randomize(arr);
    } else {
        this.lastSelected = num;
        return arr[num];
    }
}

document.querySelector("button").addEventListener("click", function() {
    console.log(randomize(["a","b","c","d"]));
});

<button>Test</button>

Note that your original function seemed to be returning a random array index, but the code shown in my answer returns a random array element.

Note also that the way you are calling your function means that within the function this is window - not sure if that's what you intended; it works, but basically lastSelected is a global variable.

Given that I'm not keen on creating global variables needlessly, here's an alternative implementation with no global variables, and without recursion because in my opinion a simple while loop is a more semantic way to implement the concept of "keep trying until x happens":

var randomize = function () {
    var lastSelected, num;
    return function randomize(arr) {
        if (arr.length < 2) return arr[0];
        while (lastSelected === (num = Math.floor(Math.random()*arr.length)));
        lastSelected = num;
        return arr[num];
    };
}();

document.querySelector("button").addEventListener("click", function() {
    console.log(randomize(["a","b","c","d"]));
});

<button>Test</button>

Answer 4

Below code is just an example, it will generate 99 numbers and all will be unique and random (Range is 0-1000), logic is simple just add random number in a temporary array and compare new random if it is already generated or not.

var tempArray = [];
var i=0;
while (i != 99) {
  var random = Math.floor((Math.random() * 999) + 0);
  if (tempArray.indexOf(random)==-1) {
        tempArray.push(random);
        i++;
  } else {
    continue;
  }
}
console.log(tempArray);