The solution, it turns out, is very simple.

Why Randomize Ads?

There are a few reasons you might want to do this.

If you’re looking into changing the theme of your AdSense ad, you may want to test the two themes against each other. By giving each theme approximately 50% of the impressions for a given time period, you can make some direct comparisons between their performance.

Or maybe you and a friend both run a website, so you want to split the advertising time between two AdSense publisher ids. That can be done too.

How the AdSense Code Works

Before we randomize it, let’s take a look at how the AdSense code works.

Here’s the snippet of code that creates the skyscraper on the left side of this page.

<script type="text/javascript"><!--
google_ad_client = "pub-2399151883698113";
/* Web Cash Tall Skyscraper */
google_ad_slot = "8702750734";
google_ad_width = 160;
google_ad_height = 600;
//-->
</script>
<script type="text/javascript"
src="http://pagead2.googlesyndication.com/pagead/show_ads.js">
</script>

You’ll notice two major pieces to this code. The first piece – in the first <script> element – defines the ad unit’s properties. It sets google_ad_client (your publisher id), google_ad_slot (the saved ad unit’s id with color info), google_ad_width, and google_ad_height.

The second section – the script element with src “show_ads.js” – actually displays the ad based on the variables that were set previously.

In order to vary the type of ad shown, we need to come up with a conditional statement to vary the google_ad_client/slot/width/height settings.

The Javascript Code…

And here’s the moment you’ve all been waiting for – the Javascript code to randomize which ad is shown.

<script type="text/javascript">
<!--
if (Math.random() > 0.5) {
  google_ad_client = "pub-2399151883698113";
  google_ad_slot = "5396010225";
  google_ad_width = 250;
  google_ad_height = 250;
} else {
  google_ad_client = "pub-2399151883698113";
  google_ad_slot = "3900536874";
  google_ad_width = 250;
  google_ad_height = 250;
}
//-->
</script>
<script type="text/javascript"
src="http://pagead2.googlesyndication.com/pagead/show_ads.js">
</script>

You’ll notice that there’s an if/else statement, and each branch of the conditional statement defines a different ad to display. The results of that conditional statement rely on the outcome of Math.random().

Previously, we built a function to get a useful random number out of Math.random(). This is actually a situation where we can use the value from Math.random() just the way it is.

Math.random() generates a random value between 0 and 1. In other words, it gives you a probability. By checking that Math.random() is greater than 0.5, the statement should evaluate to true approximately 50% of the time.

We could also make the rotation more lop-sided. For example (Math.random() > 0.70) would be true 30% of the time. Therefore the first ad would be displayed 30% of the time, while the second ad would be displayed 70% of the time.

I hope you weren’t looking for something more complicated because, well, it isn’t. It’s just that simple.

A function would be much more useful to us if it was flexible – if it could generate a list of combinations for any size set of numbers. We can’t do this with the hard coded loop solution, so we need to come up with a better method.

The Function Concept

Logically, the best way to do this is to create a function that takes a set of numbers (one combination), the size of the set being chosen from (x in [xCy]), and the size of the set being chosen (y in [xCy]). The function would then use a sequential pattern to calculate the next possible combination and return it.

With this type of function, we could create a while loop that iterates through the whole set of possible combinations. We initialize it with the first possible combination, continue to execute while the function returns a combination, and finish when the function returns 0 – in which case there are no more combinations.

If we’re finding the possible combinations for (11 Choose 4), the main loop would look something like this.

$combo = array();
$total = 11;
$choose = 4;
 
while ( $combo = getNextCombo($combo, $total, $choose) ) {
  //  Process the combo here
  //  Store it in a file, an array, or something
  //  Or just out put it
  foreach ($combo as $number) {
    echo $number . ' ';
  }
  echo '<br />';
}

This initializes an empty array – $combo. Our function takes the array and populates it with the next possible combination.

If the array is empty, it’ll create the first combination – {1, 2, 3, 4}. Otherwise, it will increment that set by one to get the next possible combination set – {1, 2, 3, 5}. When the function receives a combination set it can’t possibly increment – {8, 9, 10, 11} – it returns false and the loop ends.

Ok… How Do We Build the Function?

Let’s start by creating the function, checking for an empty array, and returning the initial set. Then we can dive into how we go about incrementing one combination set to get the next one.

function getNextCombo($combo, $total, $choose) {
  if ( empty($combo) ) {
    //  Return the first set, i.e. {1, 2, 3, 4}
    for ($x = 1; $x <= $choose; $x++) {
      $combo[$x] = $x;
    }
 
    return $combo;    
  } else {
    //  Here we'll calculate the next combination
  }
 
  //  If we didn't return before, no combination was found
  return false;
}

That should be pretty self-explanatory. Now we can look at our pattern and develop a method of calculating the next possible combination.

The Pattern

In the last article on getting combinations, we identified the basic pattern to follow.

• Find the “deepest” number that can be incremented
• Increment it by one
• Set any “deeper” numbers to one plus the previous number

The “depeest” number would be the last digit. In the set {1, 2, 3, 4}, the fourth position would be considered deepest. Here’s the first step – and the most basic increment to do.

1 2 3 4
1 2 3 5

The fourth position, ’4′, is the deepest. It can be incremented. We increment it by one. There are no deeper numbers, so we’re done.

Let’s say the fourth position is maxed out. What happens?

1 2 3 11
1 2 4 5

We move back on position to the third position. This one, ’3′, is the deepest number that can be incremented. We increment it by one to 4. Then we go down the line and set each number after it to one more than the previous. In this case we only have to set the fourth digit to one more than the third, which is 5.

Let’s take a look at one more example.

1 2 10 11
1 3 4 5

Same thing here. We move back to the second digit to find one we can increment. We increment it. We then drag the others back to be one greater than it.

Writing This in Code

The following code should go in the else { } area of the function above.

The first thing we need to do is find the deepest number that can be incremented. The deepest digit can’t be incremented when it equals $total. The second deepest digit can’t be incremented when it equals ($total – 1). The next one at ($total – 2), then ($total – 3), etc.

This loop puts that pattern into practice.

$moveBack = 0;
  while ( ($combo[$choose - $moveBack] == $total - $moveBack) 
             && ($moveBack < $choose)) {
    $moveBack++;
  }

At the end, $moveBack will hold the number of spaces from the end of the deepest digit. If $moveBack == 0, then the deepest digit can be incremented. If $moveBack == 1, we have to move up one digit to increment. So on and so forth.

If $moveBack == $choose, we can stop counting. That means that no more digits can be incremented – we’ve counted all the way back to digit #0.

Incrementing to the Next Set

Now that we know which digit can be incremented, we can increment the whole set and return the array.

First, we should check if $moveBack == $choose (to see if we’re done). If it doesn’t, we start incrementing.

We start by incrementing $combo[$choose - $moveBack]. Then we loop through, decrementing $moveBack until it is 0 – and we update the deepest digit.

if ($moveBack != $choose) {
  //  Increment the deepest digit that can be incremented
  $combo[$choose - $moveBack]++;
 
  //  Loop through and set all other numbers based on this
  while ($moveBack > 0) {
    $moveBack--;
    $combo[$choose - $moveBack] = $combo[$choose - ($moveBack + 1)] + 1;			
  }
 
  //  $combo now holds the next combination
  return $combo;
} else {
  //  We couldn't increment.  The set passed
  //    to the function was the last possible set.
  return false;	
}

And… We’re Done

If you put all the pieces together correctly, you should now have a function that iterates through all of the possible combinations given a binomial coefficient.

If you were handling large sets (millions of possible combinations), you’d probably want to re-write this in a compiled language. However, the logic is simple and based simply on arrays – so it should be easily portable to any language.

A word of warning about storing the information. Don’t try to store all of the possible combinations in a giant array. It’ll choke up all your RAM and eventually kill the script. I forget how many combinations I tried to calculate that way, but PHP maxed out at 130mb of RAM and died.

Your best bet would be to write the combinations to a data file or a database as you go. This dumps the storage requirements into a more capable format.

So what do you do with this? I’m not really sure. I wrote the script for a guy who was working on a statistical program he was using for his doctoral thesis. I’m sure there are other specialized purposes for the script – statistics and probability.

If nothing else, it’s an interesting look at how to write a computer program to tackle a complex math problem.

Here’s the full source of the script, if you had trouble putting the pieces together.

function getNextCombo($combo, $total, $choose) {
  if ( empty($combo) ) {
    //  Return the first set, i.e. {1, 2, 3, 4}
    for ($x = 1; $x <= $choose; $x++) {
      $combo[$x] = $x;
    }
 
    return $combo;    
  } else {
    $moveBack = 0;
    while ( ($combo[$choose - $moveBack] == $total - $moveBack) 
             && ($moveBack < $choose)) {
      $moveBack++;
    }
  }
  if ($moveBack != $choose) {
    //  Increment the deepest digit that can be incremented
    $combo[$choose - $moveBack]++;
 
    //  Loop through and set all other numbers based on this
    while ($moveBack > 0) {
      $moveBack--;
      $combo[$choose - $moveBack] = $combo[$choose - ($moveBack + 1)] + 1;			
    }
    //  $combo now holds the next combination
    return $combo;
  } else {
    //  We couldn't increment.  The set passed
    //    to the function was the last possible set.
    return false;	
  }
  //  If we didn't return before, no combination was found
  return false;
}
 
$combo = array();
$total = 11;
$choose = 4;
 
while ( $combo = getNextCombo($combo, $total, $choose) ) {
  //  Process the combo here
  //  Store it in a file, an array, or something
  //  Or just out put it
  foreach ($combo as $number) {
    echo $number . ' ';
  }
  echo '<br />';
}

We’ve developed mathematical formulas to help us determine the number of possible combinations – and therefore the possibility of getting any single combination – but how can we generate a list of the actual combinations?

Find the Number of Combinations: the Binomial Coefficient

Previously, we looked at how to find the total number of combinations.

Mathematically, we can use the binomial coefficient to figure this out. With a given set size (i.e. 52 cards) and a given sample size (i.e. 7 cards per hand), we can write the equation – (52 Choose 7). We could then re-write the equation as (52! / (7! * 45!) ).

In order to calculate this, we found the most efficient way was to construct two loops. The first loop calculated the numerator – after having canceled out all of the numbers contained in 45!. We then calculated the numerator by looping through 7!. With simple division, we come up with the answer.

Listing the Actual Combinations

A more interesting task, though, is to figure out how to generate a list of these combinations. To do that, let’s take a look at a manually generated list – (6 Choose 3) – and look for a pattern.

Here’s the first few combinations…

123
12 4
12  5
12   6
1 34
1 3 5
1 3  6
1   45
1   4 6
1    56
 234
 23 5

You’ll notice that there’s a pattern and that the combinations seem to be developing sequentially. If we can understand that pattern and write a script to repeat it, we’ll have done our job.

Here’s the gist of the pattern. We look at the last number. If we can increment that, we do. If not, we look back one number. If we can increment, we do. If we increment that number, we “rewind” the next number to be equal to it plus one.

For example, look at this series.

12   6
1 34

We started by incrementing the last number until it maxed out at 6. Then we moved back one space, incremented that number, and set the other number equal to one greater than that. The same thing happens when the last two numbers max out.

1   56
 234

You move back to the number that can be incremented, increment it, and then set the other numbers to one greater than the number incremented.

Using Hard-coded Loops

The easy (and cheating) way to do this is to hard code a series of nested loops that follow this pattern.

The general formula is (k Choose n) – where k is the total number of items in the set and n is the sample size being taken. We will need to create n nested loops – represent each item being chosen in our sample set.

The outer loop will go from 1 to k – (n – 1). Why? Because at k – (n – 1), we can’t increment the outer number anymore. Imagine the real numbers are (6 Choose 3). Once the outer loop gets to 4, we won’t be able to increment it any further – we’ll be at the final combination, 4, 5, 6.

The inner loop will have a beginning value that depends on the outer loop. If the outer loop is in its first iteration, the first inner loop starts at 2. When the outer loop is in its second iteration, the first inner loop starts at 3. It’s always one greater. It’s maximum value is always the same – k – (n – 2) – for the same reason we created the upper limit for the outer loop.

This continues until we get to the inner-most loop.

Here’s what these nested loops might look like in PHP, generating the combinations for (6 Choose 3).

for ($a = 1; $a <= (6 - 2); $a++) {
  for ($b = ($a + 1); $b <= (6 - 1); $b++) {
    for ($c = ($b + 1); $c <= (6 - 0); $c++) {
      echo $a . ' ' . $b . ' ' . $c . "\r\n";
    }
  }
}

You’ll see that that script outputs the correct 20 combinations for (6 Choose 3).

Can We Improve On That?

Surely we can. The main problem here is that we’ve hard-coded the loops. This is ok for a short-term solution and a small number of items being chosen.

What if you had to choose twenty items from a larger set? You’d have to hard-code twenty loops. It makes the code a bit more unseemly. This is also inflexible – you’ll have to change the code every time you have a different problem.

Instead, we need to look for a generalizable solution. This is always the best bet, but sometimes it can be tempting to look for a one-off short term solution because it’s more readily visible.

There is, however, a generalizable solution to this problem. The key lies in creating a function that finds the next combination using the sequential method outlined above. It takes a combination and returns a combination – and you can continuously call the function to iterate through all of the combinations.

Think on that for a while. It’s an interesting challenge. I’ll explain a solution to it later in the week.

Today, we’ll tackle the first part. We’ll start with a quick primer on math – what is a binomial coefficient? Then, we’ll look into the most efficient way to calculate that and get the total number of possible combinations.

What Is a Binomial Coefficient?

If it’s been a while since you took statistics or calculus, you might be scratching your head thinking about what a binomial coefficient is and what it has to do with combinations.

If you’re looking at a set of random items – let’s say 52 playing cards – and you want to pick out a number of them – let’s say a 7 card poker hand – the binomial coefficient tells you how many possible combinations you can make.

The general formula for that is usually written:

(x Choose y) = (x!) / (y! * (x-y)!)

In our example above, the total number of combinations you can get in a 7-card poker game is (52! / (7! * 45!)) or somewhere around 130,000,000.

How Do We Calculate That (in PHP)?

These methods of calculation will work for any language, really. We’ll just use PHP as an example.

The simplest way to calculate the binomial coefficient would be to loop through, calculate each factorial, and then evaluate the equation. Notice I said simple, not efficient.

$x = 52;
$y = 7;
 
$num = 1;  //  This is the numerator, 52!
for ($a = 1; $a <= $x; $a++) {
  $num *= $a;
}
 
$denOne = 1;  //  This is the first part of the denominator, 7!
for ($b = 1; $b <= $y; $b++) {
  $denOne *= $b;
}
 
$denTwo = 1;  //  This is the second part of the denominator, 45!
for ($c = 1; $c <= ($x - $y); $c++) {
  $denTwo *= $c;
}
 
$combinations = ($num) / ($denOne * $denTwo);

PHP will evaluate this properly because it’s nice and flexible with data types. Do you know how large 52! is? Try 8.06581751709E+67 large.

This is clearly too big to be an integer value, but PHP quietly converts the values to floats and keeps running. There should be a better way – one where we don’t have to calculate all of the factorials.

Method Two – Using array_diff

This method is a bit more along the lines of human logic. However, it’s still not going to be efficient. Although it’ll work with smaller numbers than the first method, it’ll take more time and memory to compute.

Basically, we’ll create three arrays. One for each set – {1, 2, 3, … 52}, {1, 2, 3, … 7}, {1, 2, 3, … 45}.

Since we know that the third set (45!) will be in the denominator and the first set (52!) will be in the numerator, we can use a nifty function called array_diff to cancel out all of the common values and shrink the numerator for us.

$newNumerator = array_diff($oldNumerator, $oldDenominator);

Then we can calculate the factorials by multiplying all of the values in the array. We can also make use of another PHP function here – array_product. It does more or less what it sounds like – it finds the product of all the values in an array.

$num = array();
for ($a = 1; $a <= $x; $a++) {
  $num[] = $a;  // the numerator array, 52!
}
 
$denOne = array();
for ($b = 1; $b <= $y; $b++) {
  $denOne[] = $b;  //  The first denominator array, 7!
}
 
$denTwo = array();
for ($c = 1; $c <= ($x - $y); $c++) {
  $denTwo[] = $c;  // The second denominator array, 45!
}
 
//  Use array_diff to cancel out the common values in 52! and 45!
$num = array_diff($num, $denTwo);
$combinations = array_product($num) / array_product($denOne);

This keeps the numbers much smaller. Therefore we can work with bigger combinations before PHP putts out. However, the arrays can eat up a lot of memory and processing power… so there still should be a better way.

Combine the Two Concepts

The more efficient way is to combine the two concepts. We’ll use the first method of multiplying through a loop to generate the factorials. This is far more efficient than iterating an array.

However, we’ll still cancel out the common values between 52! and 45!. To do this, we modify the first loop so that it counts down from $x (52) to $x – $y (45). Then we simply ignore the third loop – since it’s values were essentially counted when we calculated the first loop.

$num = 1;
for ($a = $x; $a > $x - $y; $a--) {
  $num *= $a;
}
 
$den = 1;
for ($b = 1; $b <= $y; $b++) {
  $den *= $b;
}
 
$combinations = $num / $den;

At this point, our script is pretty efficient. It doesn’t use up a lot of memory, it executes quickly, and it’s not calculating very many redundant values.

However, there’s still a limit to what we can do. The biggest number PHP seems to be able to calculate is 170!. After PHP sees the value 7.25741561531E+306 it just seems to give up. Geez, like 300 zeroes is a lot.

You could improve this a bit more, and increase the number of combinations it could compute. Rather than calculating the $numerator and $denominator separate, as we did here, you’d want to calculate the $denominator first and then cancel out values as you multiply the numerator.

In other words, calculate the $denominator as normal. Then, while you’re looping through to calculate the numerator, you factor out any common values in the $denominator and the number about to be multiplied into the numerator.

Who Cares About How Many Combinations… I Want to See Them

This is really the boring part. Who cares how many combinations there are? We can easily find that with a calculator.

The interesting part – where we definitely need a computer to help us – is to iterate through the set and find all of the possible combinations. We’ll come back to this later in the week.

At the suggestion of a reader (thanks Justin), I decided to go ahead and turn the general formula for this into a short helper function to generate a random number.

Random Numbers: General Formula

First, let’s take a minute and recap the general formula for finding a random number.

Javascript’s Math.random() method returns a random number between 0 and 1. By multiplying this decimal value by a whole number, we can generate a desired range of values. For example, by multiplying Math.random()’s result by 10, we get a range of 0 to 10.

Next, we take the Math.floor value of that random number. This gives us just the integer portion – and it effectively cuts our range to 0 through 9. Finally, we can modify this by adding an offset number. So if we wanted a random number between 51 and 60, we’d add 51 to that result.

Creating a Random Number Function

The basic formula we end up with is…

(Math.floor( Math.rand() * setSize)) + setOffset;

Our code would be much more readable if we had a helper function that could be called like this…

randomNumber = rand(min, max);

Our function is going to take two parameters – min and max. From these two parameters, we can calculate the offset and the set size and generate the proper random number.

function rand(min, max) {
  var offset = min;
  var range = (max - min) + 1;
 
  var randomNumber = Math.floor( Math.random() * range) + offset;
  return randomNumber;
}

All done.

Add that function to a utility file, and you’ve got a handy random number generator at your disposal. It even uses the same format as PHP’s rand() function, to help increase consistency and readability in your code.

While I was working on various game-related scripts this weekend, I was left wondering how to create a random number in Javascript. It’s not quite as simple as the rand() function – we’ll have to go back to the old C-style random number generation.

The Math Object and Random Numbers

Javascript comes with a built-in random number generator as part of the Math object. This Math object does a number of calculations – trig functions (sine, cosine, and tangent), rounding, logarithms, exponents, etc.

To use the Math class to generate a random number, you begin with the random method.

Math.random();

This method returns a random value – between 0 and 1.

How Can I Make a Useful Random Number?

If you’ve ever programmed in C/C++, you’ll know what to do. If you’re used to working with something like PHP – which comes with an intelligent built-in random number generator – you may be left in the dark.

How can you take a random decimal – between 0 and 1 – and turn it into a random number between, say, 1 and 100?

The answer is simple – math. You need to multiply the random() result to get a certain sized range and then use addition to start the range at the right number.

Let’s say you multiply the result of Math.random() by 10.

Math.random() * 10

Since the results of Math.random() are between 0 and 1, the results of this statement will be 0 to 10. The minimum result is (0 * 10 = 0) and the highest result is (1 * 10 = 10).

If you were to only look at the whole number part of the result, you would get a range of 0 to 9. In actuality, the result of Math.random() is never 0 or 1, so the above statement won’t give you a result of 10.

Therefore we can use the whole number portion of the result to get a random integer – 0 to 9.

How Do We Get a Whole Number?

Simple. Use the floor method of the Math class. Math.floor returns the whole number portion of a float/decimal.

Math.floor(1.45); //  Result is 1

Simply pass a float/decimal to the Math.floor method, and it will return the integer portion of that number. If you’re working with negative numbers, it will always round down. Keep that in mind. For positive numbers, it’s simply a truncation function.

To get a random integer, we simply pass the result of Math.rand() to Math.floor().

Math.floor( Math.rand() );

What If My Random Set Doesn’t Start at 0?

Here’s the last piece of the random puzzle.

You can determine the size of your random number set with multiplication. The coefficient you use (like we used 10 before) determines the range your random number can be in.

Math.floor( Math.rand() * 10); // 10 Numbers, 0-9
Math.floor( Math.rand() * 5); // 5 Numbers, 0-4
Math.floor( Math.rand() * 100); // 100 Numbers, 0-99

If the set you want to create a random number from doesn’t start with 0, you simply use addition to get what you want.

Let’s say you want a random number from 101-150. Your set contains 50 numbers, and it starts with 101.

(Math.floor( Math.rand() * 50)) + 101; // 101 - 150

The basic statement – Math.floor( Math.rand() * 50) – returns a value between 0 and 49. We want to offset that by 101 places and we’ll have our desired random set – 101 to 150.

At this point, you should have a general equation you can use for generating random numbers from any given set. Take Math.rand(), apply a coefficient to determine the size of the random number set, and then use addition to offset that number to your desired starting point.

(Math.floor( Math.rand() * setSize)) + setOffset;

Now go find something useful to use these random numbers for.