views:

107

answers:

5

I need help with writing some code that will create a random number from an array of 12 numbers and print it 9 times without dupes. This has been tough for me to accomplish. Any ideas?

A: 

If I understand you correctly, you want to shuffle your array.

Loop a couple of times (length of array should do), and in every iteration, get two random array indexes and swap the two elements there. (Update: if you are really serious about this, this may not be the best algorithm).

You can then print the first nine array elements, which will be in random order and not repeat.

Thilo
A: 

This is relatively simple to do, the theory behind it is creating another array which keeps track of which elements of the array you have used.

var tempArray = new Array(12),i,r;
for (i=0;i<9;i++)
    {
    r = Math.floor(Math.random()*12);    // Get a random index
    if (tempArray[r] === undefined)      // If the index hasn't been used yet
        {
        document.write(numberArray[r]);  // Display it
        tempArray[r] = true;             // Flag it as have been used
        }
    else                                 // Otherwise
        {
        i--;                             // Try again
        }
    }

Other methods include shuffling the array, removing used elements from the array, or moving used elements to the end of the array.

Andrew Dunn
Don't use the above code for professional works though, it is an extremely simple example used to demonstrate the logic behind what you are trying to do (printing 9 values from an array of 12 values in random order).
Andrew Dunn
It does seem to produce an unbiased sequence of numbers, though. The only problem I can see is performance as it gets increasingly more difficult to find the remaining numbers.
Thilo
Exactly, while that algorithm will suffice for smaller sets of data, for larger sets, you need to make sure collisions don't occur, either by removing data from the array, or pushing it to the end.
Andrew Dunn
A: 
var nums = [1,2,3,4,5,6,7,8,9,10,11,12];
var gen_nums = [];

function in_array(array, el) {
   for(var i = 0, j = array.length; i < j; i++) 
       if(array[i] == el) return true;
   return false;
}

function get_rand(array) {
    var rand = array[Math.floor(Math.random()*array.length)];
    if(!in_array(gen_nums, rand)) {
       gen_nums.push(rand); 
       return rand;
    }
    return get_rand(array);
}

for(var i = 0; i < 9; i++) {
    document.write(get_rand(nums));
}
Jacob Relkin
A: 

Try this once:

//Here o is the array;
var testArr = [6, 7, 12, 15, 17, 20, 21];
    shuffle = function(o){ //v1.0
                        for(var j, x, i = o.length; i; j = parseInt(Math.random() * i), x = o[--i], o[i] = o[j], o[j] = x);
                        return o;
                };
shuffle(testArr);
Sudhir
+1  A: 

The most effective and efficient way to do this is to shuffle your numbers then print the first nine of them. Use a good shuffle algorithm.What Thilo suggested will give you poor results. See here.

Edit Here's a brief Knuth Shuffle algorithm example:


void shuffle(vector<int> nums)
{
  for (int i = nums.size()-1; i >= 0; i--)
  {
    // this line is really shorthand, but gets the point across, I hope.
    swap(nums[i],nums[rand()%i]);
  }
}
JoshD
Using the proven algorithms you suggest does seem like a better idea if one is serious about it. I'd just like to point out that the algorithm I suggested is not the one discussed unfavourably in "see here".
Thilo
It isn't the same algorithm, no. But I fear it would still produce the same error if I understand right. There are n^3 outcomes for your algorithm that will land in one of n! boxes. That cannot give an even distribution. Try the experiment in the article with your algorithm and see if it works.
JoshD
In the comments to the blog you linked, "my" algorithm is brought up by "fabio". He claims that it works, but with a bigger number of swaps (not just the array size). I'll read up on it a little more, and see if I can prove it right or wrong. Andrew Dunn's proposal below seems statistically correct, too, even though it has performance problems.
Thilo
I looked at that comment you pointed out. I still feel that the number of paths must be divisible by n! to fit evenly into n! outcomes, but I may be mistaken. I'd be interested to see what you find comparing Knuth's algorithm to yours side by side. And yes, Dunn's algorithm should work (despite performance).
JoshD
I am taking it to the statisticians: http://stats.stackexchange.com/questions/3082/what-is-wrong-with-this-naive-shuffling-algorithm
Thilo
Cool. I'll keep my eyes on it. Thanks! Maybe add a link to the Coding Horror article? :)
JoshD