PHP-Scripts Blog » Random

How to randomize, return and remove numbers from a pool

TDavid — Mon, 11 Dec 2006 17:30:17 +0000

This morning in the IRC chat (irc.scriptschool.com #scriptschool) a random visitor named Rnd-Amarion stopped by with the following how-to PHP question:

I am about to learn PHP, and want to program a simple web page with a long string of random numbers. I have the random numbers allready. When someone queries the web site, it retrieves four of those numbers from the front of this list and gives them to the querier and then removes those numbers form the front fo the list.

I asked him what were the range of numbers he wanted randomized. While this information wasn’t critical to writing the code to solve this how-to, it would better demonstrate to him (her? I didn’t ask). Didn’t get a response but I decided to help this unknown person anyway.

Let’s consult the PHP manual for the function array_rand (PHP 4, 5) and the definition:

array_rand — Pick one or more random entries out of an array

That sounds like the right function, but with most programming languages there are many ways to approach the same problem. Let’s create some code to do this using the PHP functions range, shuffle and array_shift.

$random_numbers = range(1,100);
shuffle($random_numbers); // mix up the order
// return the first four numbers when queried and remove from array
$numbers_chosen = array($random_numbers[0], $random_numbers[1], $random_numbers[2], $random_numbers[3]);

print “Before:
”;
print_r($random_numbers); // show all random numbers

// remove first four numbers
for($i=0;$i<4;$i++) {
array_shift($random_numbers);
}

print“

After: “;
print_r($random_numbers); // show all remaining random numbers
print“

Chosen: “;
print_r($numbers_chosen); // first four numbers chosen

Example: code execution, code source

Notes: The array_shift function removes the first item in an array. The converse array_pop removes the last item in an array. Another useful array function is array_splice.

Update 9:55am PST: You can see a more efficient version using array_splice here that eliminates the use of the for loop in the code above and the use of array_shift. As for which is more efficient for removing only one item in the array, that’s a test for you to run :)

Random web page background colors

TDavid — Fri, 14 Jul 2006 13:51:01 +0000

If you want to create a random background color

$hex = dechex(rand(0,255)) . dechex(rand(0,255)) . dechex(rand(0,255)); ?>

and then you’d use the following in your body tag:

“#”>

How to not show the same thing twice when randomizing

TDavid — Tue, 13 Dec 2005 04:04:20 +0000

Last night I was reviewing a new site that randomizes pages and I kept seeing the same pages coming up repeatedly. This is a rather common problem with many basic randomizers that do not keep track of what has already been shown.

This begs the question: how do you setup even distribution of a randomized pool of content? There are a couple different ways to do this, some of which are extremely efficient, but today we’ll review one that is very efficient and scales nicely.

First we need to pre-randomize the results and save an index of where we are at in the randomized pool. For example let’s say you have 10 numbers you want to randomize like this:

$numbers = range(1,10); // fill with numbers 1-10
shuffle($numbers); // as of PHP 4.2.0 no need to seed with srand()
foreach($numbers as $each) {
print “#1: $each
”; // display all random numbers
}
?>

Now you would just need to remember the position of the randomized array from page to page so that the next randomized item in the array is displayed. To do this within the same browsing session we coud use sessions. To do this across browser sessions, we could use cookies. Here is some code illustrating how to do this using a session:

session_start();
if($_SESSION[‘index’] == 10 or $_SESSION[‘index’] == ”) {
// first or LAST time, generate numbers
$_SESSION[‘index’] = 0;
$rnumbers = range(1,10);
shuffle($rnumbers);
$_SESSION[‘numbers’] = $rnumbers;
}

$curindex = $_SESSION[‘index’];
$rnumbers = $_SESSION[‘numbers’];
print ‘Current randomize (#’ . ($curindex+1) . ‘): ’ . $rnumbers[$curindex] . ‘

’;
$x = 1;
foreach($rnumbers as $each) {
if(($x-1) == $curindex) {
print “#$x: $each
”; // display all random numbers
} else {
print “#$x: $each
”; // display all random numbers
}
$x++;
}
$_SESSION[‘index’] = $curindex+1;
print ‘
Refresh or click for next randomized number. When all 10 numbers have cycled, a new shuffle of numbers in the pool will occur.’;
?>

Notes: start the code with session_start() to initialize the session. Then we check to see if the $_SESSION[’index’] is set or has reached the ceiling of the array. If the ceiling has been reached (10 numbers) then we reshuffle the array and reset the index to the first position.

This code also illustrates how to highlight the current item selected in a foreach loop in a bold green font. Since arrays begin numbering at zero but lists start numbering at 1, it is necessary to add and subtract one where applicable in the code. The $x variable is a list counter variable.

What if you want to add new content to the array?
Say you are currently at item #6 and there has been two new numbers added? You could wait until the current cycle is complete and re-randomize the numbers for that user or you could re-randomize the remaining indices with the new content added pushed to the end. You could then fill a new array with the remaining numbers, shuffle that and then replace the existing $numbers array starting at the next index number. This way the user would not see the content they’d already seen and would see the new content randomized into the list.

Above and beyond
This technique could be used for anything you could put into an array. If the array size is very big then you might want to work in stages, for example only load in 50 or 100 items into the session variables at a time as opposed to loading in thousands of possible pointers. Once the user has reached the random point, just grab a new randomized set of numbers from set #2 then set #3, etc all the way until all the pool has been exhausted.