Shuffle An Array In PHP

24th January 2008 - 3 minutes read time

Note: This post is over a year old and so the information contained here might be out of date. If you do spot something please leave a comment and I will endeavour to correct.

To randomise an array in PHP use the shuffle() function like this.

$array = range(1, 5);
shuffle($array); // randomise array

There are two limitations to this function. The first is that it completely removes any key association that you may have set up. So the following array.

$array = array('one'=>1,'two'=>2);

Would be turned into the following after using shuffle().

Array
(
  [0] => 2
  [1] => 1
)

A way around this is to use the following function, this uses the PHP function array_rand() to extract the all of the keys in the array in a random order before ensuring that the key associations are in place.

function shuffle_me($shuffle_me){
  $randomized_keys = array_rand($shuffle_me, count($shuffle_me));
  foreach($randomized_keys as $current_key) {
    $shuffled_me[$current_key] = $shuffle_me[$current_key];
  }
  return $shuffled_me;
}

The second limitation to the shuffle() function is the degree of randomness that is created. In order to give a rough estimate of how random a randomising function is you can use the following code.

$rangeStart = 1;
$rangeEnd = 2;
$loops = 100000;
$results = array();
for($i=0;$i<=$loops;$i++){
  $numbers = range($rangeStart,$rangeEnd);
  shuffle($numbers); // carry out randomise here
  $results[] = implode(',',$numbers);
};
$tmp = array_count_values($results);  
arsort($tmp);
echo '<pre>'.print_r($tmp,true).'</pre>';
$start = current($tmp); // get first item
$end = end($tmp); // get last item
echo '<p>Start: '.$start.' End: '.$end.' Difference: '.($start-$end).'</p>';

This code runs a loop 100,000 times, each time it creates a small array containing the values 1 and 2, randomises it and then stores the result as a string of numbers in another array. After the loop the PHP function array_count_values() is used to count the number of times that each value has been created and then looks to see the difference between the the lowest occurring value and the highest occurring value. The greater the number the more random the randomising function is. This shouldn't be used as the absolute truth because there are more factors at work with randomising arrays, but it gives a nice approximation.

To get a good level of randomness with an array randomising function you should use the Fisher-Yates shuffle. Here is an example of a function that uses this algorithm.

function array_shuffle($array){
  // shuffle using Fisher-Yates
  $i = count($array);
 
  while(--$i){
  $j = mt_rand(0,$i);
    if($i != $j){
      // swap items
      $tmp = $array[$j];
      $array[$j] = $array[$i];
      $array[$i] = $tmp;
    }
  }	
  return $array;
}

Using the previously mentioned random testing code it was found that the native PHP shuffle() function gave an average difference of 27, whereas the Fisher-Yates shuffle gave an average difference of 273.

So if randomness is very important to you then you probably shouldn't use the shuffle() function.

array

Comments

Permalink

heyy thanks for the article. very useful. the shuffle wasn't giving me very good randomization.

Permalink

Hi, I found your page with this php array searching with Google. I am writing you to see if you can help me. I have one (1) topsite list with banners rotating at the center, left and right. The problem is that I'm developing a second topsite with the same structure, same code, same array, but I cannot get rotate banners, there is no way to make them rotate. The array I am using is very similar to yours: //randomly shuffle the array keeping the relation between keys and values function shuffle_me($shuffle_me){ $randomized_keys = array_rand($shuffle_me, count($shuffle_me)); foreach($randomized_keys as $current_key) { $shuffled_me[$current_key] = $shuffle_me[$current_key]; } return $shuffled_me; } $center_banners=shuffle_me($center_banners); $center_banners=array_slice($center_banners, 0, 20); $left_banners=shuffle_me($left_banners); $right_banners=shuffle_me($right_banners); ?> Could you help me? I am really very little expertise in this area, I do not understand why the script works perfectly in one topsite and in another topsite, which is a clone of the first one, does not work. What determines that the banners rotate in addition to the script? Thanks for your help Marlon

Add new comment

Conway's Game Of Life In PHP

I was saddened to hear of the passing of the Mathematician John Horton Conway today so I decided to put together a post on his 'game of life' simulator.

This game of life, more commonly called Conway's game of life, was devised by John Conway in 1970 and is a way of modelling very simple cell population dynamics. The game takes place on a two dimensional board containing a grid of orthogonal cells. The game is technically a zero player game in that the initial setup of the game dictates the eventual evolution of the board.

The rules of the game (taken from wikipedia) are as follows.

Bogo Sort In PHP

I came across this sorting algorithm the other day called 'bogo sort'. This is a sort of joke sorting algorithm that is highly ineffective at actually sorting arrays. The name comes from the word 'bogus'.

Here is how it works.

Take an array.
Shuffle it.
If the array sorted then stop.
If the array is not sorted then return to step 2.

As you can see, this isn't so much a sorting algorithm, more of a game of chance. Due to the random nature of the sort you might need to wait a very long time before the array is actually sorted.

Here is an implementation of a bogo sort in PHP.

An Implementation Of Array Binary Search In PHP

I have been doing some reading and watching lectures of programming theory recently and I was reminded of this algorithm I learned about in university. Binary searching an array is a divide and conquer algorithm that takes an array and searches for a value in that array by splitting the array into halves. The algorithm works like this.

Sieve of Eratosthenes In PHP

The sieve of Eratosthenes is named after Eratosthenes of Cyrene who was a Greek mathematician who devised a mechanism to find a sequence of prime numbers using a simple algorithm.

Normally, looping through a list of numbers and finding the primes can be an expensive process. The seive of Eratosthenes is one of the most efficient way of working out all of the smaller prime numbers below (below 10 million or so).

The sieve works by looping through a list of consecutive numbers, starting at 2. For each number in the sequence the multiples of that number are marked to be removed from the list of numbers. When finished the numbers that are not marked are prime numbers.

This algorithm is pretty straightforward, but from that it is possible to create a simple PHP function that will generate all the prime numbers up to a given number.

Finding The First And Last Items In An Array In PHP

Getting the first or last item from an array in PHP is usually quite easy. If you create an array and then add a bunch of values to it then the array index will increment by 1 for every element you add. This means that in order to get the first element from an array you just reference the default starting position (0). To get the last item in the array the index key will be the length of the array, minus 1. Here is some example code showing this.