Select random elements from an array without repeats?

Blatantly stealing from @32bitKid, this is my version.

The main problem I have with his solution is the push/splice idea. As much as possible, I like to create once, and reuse. Shrinking and growing arrays is bulky, even if effective.

Also, this method does not re-order the array, which may or may not be valuable.

BTW, I like the way that he prevents a repeat of the previous item ("almost empty").

So here is another method:

package
{

    public class RandomizedList
    {
        private var _items:Array;
        private var idxs:Array;
        private var rnd:int;
        private var priorItemIdx:int;
        private var curIdx:int;

        public function RandomizedList(inarr:Array)
        {
            items = inarr;
        }

        private function initRandomize():void
        {
            idxs = new Array();

            //Fisher-Yates initialization (http://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle):
            idxs[i] = 0;
            for (var i:int = 1; i < items.length; i++)
            {
                rnd = int(Math.random() * (i + 1));
                idxs[i] = idxs[rnd];
                idxs[rnd] = rnd;
            }

            curIdx = 0;
            priorItemIdx = -1;
        }

        private function randomize():void
        {
            var tempint:int;
            //Fisher-Yates (http://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle):
            for (var i:int = items.length; i >= 1; i--)
            {
                rnd = int(Math.random() * (i + 1));
                tempint = idxs[i];
                idxs[i] = idxs[rnd];
                idxs[rnd] = tempint;
            }

            curIdx = 0;
        }

        public function next():void
        {
            if (curIdx >= idxs.length)
            {
                randomize();
            }

            if (items.length > 1 && priorItemIdx == idxs[curIdx])
            {
                curIdx++;
            }

            priorItemIdx = idxs[curIdx++];
            return items[priorItemIdx];
        }

        public function get items():Array
        {
            return _items;
        }

        public function set items(value:Array):void
        {
            _items = value;
            initRandomize();
        }
    }
}

I would use a utility class like this to abstract out the behavior I wanted:

import flash.text.TextField;

class Randomizer {

    private var unused:Array = [];
    private var used:Array;

    public function Randomizer(playList:Array) {
        used = playList;
    }

    public function next():* {
        // If almost empty, refill the unused array
        if(unused.length <= 1) refill();

        // Get the first item off the playList
        var item:* = unused.shift();

        // Shove it into the bucket
        used.push(item); 

        // return it back
        return item;
    }

    public function refill():void {
        var i:int;
        // Fisher-Yates shuffle to refill the unused array
        while(used.length > 0) {
            i = Math.floor(Math.random() * used.length)
            unused.push(used.splice(i,1)[0])
        }
    }
}

Notice that it refills the unused array when the unused array still has one item in it, this makes it impossible for the last result to repeat twice in a row. This will return each item once before before looping, and will never repeat the same item twice.

You would use it by saying something like:

var ads:Randomizer = new Randomizer(["Image1", "Image2", "Image3"]);
ads.next(); // will return something
ads.next(); // will return something
ads.next(); // will return something
ads.next(); // will return something
// Keep going into infinity...

There is a little test example of this code working here.

See if this makes any sense

//create your array of all your ad names/frame labels
var PrepMCs:Array = new Array("Image1", "Image2", "Image3");

var shuffledMCs:Array = [];

//store the name of the last played ad in this var
var lastAdPlayed:String;

//shuffle the array
shuffleArray(PrepMCs);


function shuffleArray(arrayToShuffle:Array):void {  
//clear the array
shuffledMCs = [];

var len:int = arrayToShuffle.length;

for(var i:int = 0; i<len; i++) {
shuffledMCs[i] = arrayToShuffle.splice(int(Math.random() * (len - i)), 1)[0];
}

//test to see if the new first ad is the same as the last played ad
if (lastAdPlayed == shuffledMCs[0]) {
//reshuffle
    shuffleArray(PrepMCs);
} else {

lastAdPlayed = [0];

trace(shuffledMCs);

playAds();
}    

}



//after each ad has played, call this function
function playAds():void {

if (shuffledMCs.length > 0) {

    gotoAndPlay(shuffledMCs[0]);
    shuffledMCs.splice(0,1);

} else {
    //array is empty so we have played all the ads
    shuffleArray(PrepMCs);
}

}