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.

One of the Frihost users and his friend made a 3d Worm game. Although the directions are in Spanish (as is the source code), the game is pretty cool. It’s a good example of what you can accomplish with some Javascript/DOM trickery.

Playing the game is simple enough. You use the four arrow keys and the Q/A key to pick one of six directions to go in.

At first, it can be very difficult to gauge the “3d” position of the apple. Once you learn to use the shadows to your advantage, the game becomes pretty easy. It’s still fun, though, and a great example of how Javascript can be used to make an interface for a game.

You see a few cool things here.

For one, the script captures keyboard input to drive the action. Rather than clicking on buttons/boxes on the screen, the user can hit the appropriate keys and the game responds. This is important for making a game feel “real” and not a kind of mash-up.

A lot of the positioning is done with “position: absolute” and the “top”/”left” styles. This let’s you use the screen as a kind of canvas – drawing the images where-ever you need them. It frees you from the constraints of normal HTML positioning, where you need to float/margin/padding stuff to get it to line up where you want.

It’s possible to read source code written in another language. I just find this interesting. The source is written in Spanish – so most of the variable/function names don’t mean a lot to me. However, the code is pretty straightforward so it’s still easy enough to follow what’s going on.

Well go play some Worm. This has inspired me to go do some coding.