## PHP Question: Variable Reference

## Question

What does the following code print out?

```
function arrayPrint($array)
{
echo implode(' ', $array);
}
$arrayA = [1, 2, 3];
$arrayB = $arrayA;
$arrayB[1] = 0;
arrayPrint($arrayA);
```

What does the following code print out?

```
function arrayPrint($array)
{
echo implode(' ', $array);
}
$arrayA = [1, 2, 3];
$arrayB = $arrayA;
$arrayB[1] = 0;
arrayPrint($arrayA);
```

The Luhn algorithm was created by Hans Peter Luhn and is a way of creating a simple checksum for a number. This algorithm, also known as the mod 10 algorithm, is used in a wide variety of applications but is commonly associated with credit card numbers.

If you look at the numbers on the front of your credit card the last digit on the right is the checksum. An algorithm is done on the other numbers and if the checksum is the same then the number is considered valid.

Outside of credit card numbers, the Luhn algorithm can be used to create a checksum on any number that you want to store. It is especially handy when you want to give users a number that they will be hand typing into a computer. The checksum helps spot any errors in typing in the number before that number is processed. The good thing about the Luhn algorithm is that it doesn't matter how long the number is so it will work with any kind of digit sequence.

I was looking for a function that searched an array for another array, and after not finding one I decided to write it. What I was looking for was a function that took a smaller array and searched for that exact sequence of items in a larger array. As it happens, PHP does have a number of array search functions, but they didn't produce the correct result.

The array_search() function does accept an array as the needle to be searched for, but this does a multi-dimensional search instead. I also saw some techniques using array_intersect() or array_diff(), and although these functions were able to find one array inside another I was interested in the sequence.

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.

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.

A simple way to convert a string into a set of variables is through the use of the explode() and list() functions. list() is a language construct (not really a function) that will convert an array into a list of variables. For example, to convert a simple array into a set of variables do the following:

`list($variable1, $variable2) = array(1, 2);`

In this example $variable1 now contains the value 1 and $variable2 contains the value 2. This can be adapted to use the explode() function to take a string and convert it into a set of variables. An example of this in use might be when dealing with addresses, simply explode the string using the comma and you have a set of variables.

```
$address = '123 Fake Street, Town, City, PO3T C0D3';
list($street, $town, $city, $postcode) = explode(',', $address);
```

You can now print out parts of the address like this:

Use the following array to print out a list of Canadian states, also know as provinces.

```
$canadian_states = array(
"BC" => "British Columbia",
"ON" => "Ontario",
"NL" => "Newfoundland and Labrador",
"NS" => "Nova Scotia",
"PE" => "Prince Edward Island",
"NB" => "New Brunswick",
"QC" => "Quebec",
"MB" => "Manitoba",
"SK" => "Saskatchewan",
"AB" => "Alberta",
"NT" => "Northwest Territories",
"NU" => "Nunavut",
"YT" => "Yukon Territory"
);
```

Here is the same array, but with the French versions of the states.

The array_flip() function in PHP is used to swap the values of an array with the keys. Take the following array.

`$array = array('key1'=>'value1', 'key2'=>'value2');`

To exchange all the values with the keys we pass it through the array_flip() function.

```
$array = array_flip($array);
echo '<pre>'.print_r($array, true).'</pre>';
```

This prints out the following:

```
Array
(
[value1] => key1
[value2] => key2
)
```

If any of the values are the same then the highest key is overwritten. The following array:

`$array = array('a', 'a', 'a', 'b');`

Will produce the following array when passed through array_flip().

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.